From 38b5f9e99a5ce3f267c004362acf00ac0dc11342 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:20:04 +1030 Subject: [PATCH 01/22] formal(mat009): pin source split gate and finite boundary cases --- .../mat009/source/CALLER_DOMAIN.md | 138 ++++++ formal/sonification/mat009/source/CONTRACT.md | 173 +++++++ .../sonification/mat009/source/HANDOFF.json | 79 ++++ .../mat009/source/SOURCE_BINDING.json | 79 ++++ .../sonification/mat009/source/source_bind.py | 235 ++++++++++ .../test_sonification_formal_mat009_split.py | 423 ++++++++++++++++++ 6 files changed, 1127 insertions(+) create mode 100644 formal/sonification/mat009/source/CALLER_DOMAIN.md create mode 100644 formal/sonification/mat009/source/CONTRACT.md create mode 100644 formal/sonification/mat009/source/HANDOFF.json create mode 100644 formal/sonification/mat009/source/SOURCE_BINDING.json create mode 100644 formal/sonification/mat009/source/source_bind.py create mode 100644 tests/test_sonification_formal_mat009_split.py diff --git a/formal/sonification/mat009/source/CALLER_DOMAIN.md b/formal/sonification/mat009/source/CALLER_DOMAIN.md new file mode 100644 index 0000000..fa0464f --- /dev/null +++ b/formal/sonification/mat009/source/CALLER_DOMAIN.md @@ -0,0 +1,138 @@ +# MAT009 caller domain and bridge limits + +This analysis concerns the frozen MAT009 `check_future_challenge` function and +its direct MAT008 validator call. `CONTRACT.md` gives the source order and +reason conditions. The source binder confirms bytes and selected syntax only. +No theorem about the behavior of arbitrary CPython objects follows from that +binding, and no metadata in this packet authenticates physical experiments. + +## A tractable exact built-in domain + +For a model of the normal row-scan path, a narrow input domain is: + +1. `type(records) is list` and `1 <= len(records) <= 10000`. +2. Every element has `type(row) is dict`; every key has `type(key) is str`. + Every value read by either validator has exact type `str`, `bool`, or + `NoneType`, and all string identities used as map or set keys have exact + type `str`. Missing keys produce the ordinary `None` from built-in + `dict.get`. +3. The list and dictionaries are not mutated while the call runs. The imported + modules, built-ins, regex objects, and `Fraction` implementation are not + monkeypatched during the call. + +This domain permits malformed text, absent fields, and both exact Boolean +values, so it can model negative reasons. A still narrower passing fixture +also supplies the required field texts, two disjoint campaign/lab families, +both phases in each partition and campaign, distinct source and diagnostic +identities, and one shared syntactically valid receipt. Passing those +structural assertions does not authenticate any experiment or preregistration. + +On this domain, built-in strings obey ordinary textual equality and +hash-consistency, and built-in dictionaries and sets provide the expected +lookup and intersection behavior. A source-to-model bridge would still need +to establish, rather than assume, the following: + +- The MAT008 parent result for the *same* input list, including its skip paths + and sorted reasons. The MAT009 child only imports that reason list. +- The MAT009 early result shape, three child skip paths, and state-update + order. Parent eligibility is different: MAT008 requires five identities; + MAT009 requires only campaign and lab after role acceptance. +- Campaign role conflict, split campaign/lab/phase sets, both independent + diagnostic owner maps, valid receipt set, final checks, sorted reason union, + and the constant nonadmission result fields. +- The exact behavior of Python `isinstance`, regular expressions, + `Fraction`, `dict.setdefault`, dictionary overwrite, set intersection, and + sorted strings in the chosen interpreter. `SOURCE_BINDING.json` does not + supply these semantic lemmas. + +The MAT008 validator itself is still only a structural metadata check. A +future refinement theorem must not turn a structural pass into a claim of +source independence, a real holdout, classifier performance, or physical +validation. + +## Why the exact-type boundary matters + +The released source uses `isinstance`, not exact type tests. Consequently it +accepts subclasses at its outer list check, its row dictionary check, and its +identifier/digest checks. The finite tests retain these concrete observations: + +| Outside-domain input | Frozen CPython observation | Consequence | +| --- | --- | --- | +| Two `str` subclass campaign IDs with equal text `SAME_CAMP` but hashes 11 and 23, one object reused within each split | `_identifier` and MAT008 `_identity` accept them. Both validators can return no reasons, and MAT009 returns `STRUCTURAL_ONLY_UNAUTHENTICATED`. Replacing them with one exact built-in string causes campaign cross-split and source-family leakage reasons. | A textual-equality split theorem does not refine to arbitrary `str` subclasses with inconsistent hashes. No physical evidence is admitted in either result. | +| `dict` subclass whose `.get` raises `RuntimeError` | The MAT008 call propagates that exception before the child scan. | `isinstance(row, dict)` alone does not make the function total. | +| Unhashable `str` subclass used as a row ID | MAT008 `_identity` accepts the text; inserting the ID into `seen_rows` raises `TypeError`. | The direct parent has a dynamic hashability boundary. | +| Exact integer `1` as every `synthetic_fixture` value | The parent's `is True` test does not add `SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT`; otherwise sound self-declared fields return structural-only. | An equivalence with a truthiness-based flag model is false. Physical admission still stays false. | + +Exact built-in strings rule out the first and third cases. Exact dictionaries +rule out the overriding `.get` case. Requiring a missing or exact Boolean +`synthetic_fixture` rules out the truthy integer case. A wider domain may be +valid, but needs separate semantic work and tests; the current evidence does +not claim one. + +The outer guard itself is deliberately wider than the proposed normal-path +domain: it returns its five-key blocked result for non-lists, empty lists, and +lists longer than 10,000. A `list` subclass can override truthiness, length, +or iteration, so it is not covered by that simple exact-list account merely +because `isinstance(records, list)` is true. A `dict` subclass may similarly +override `.get`. Other custom values can alter equality, hashing, or raise +exceptions. The source contains no general exception handler around the +parent or child scan. + +## Operational distinctions a model must retain + +MAT008 validates the five source identities before touching its campaign, +phase, run, document, or digest state. MAT009 validates role plus campaign and +lab, then processes the row even if MAT008 rejected its run, document, or row +ID. For example, a missing run on the first train row produces MAT008's +`MISSING_OR_INVALID_SOURCE_IDENTITIES` and +`BOTH_PHASES_REQUIRED_FOR_EACH_CAMPAIGN`, but MAT009 still counts that row's +train phase. It does not add `TRAIN_REQUIRES_BOTH_PHASES`. + +Conversely, a row with an undeclared role can be fully processed by MAT008 +while MAT009 skips its units, receiver, diagnostic, receipt, and split state. +In the finite case where the skipped row also has bad unit, scale, diagnostic +SHA, and receipt, the only child reasons are +`UNDECLARED_TRAIN_HOLDOUT_ROLE` and `TRAIN_REQUIRES_BOTH_PHASES`. A model that +checks all fields before the role guard would add false reasons. + +The child campaign map overwrites the last role for a campaign after recording +a cross-role conflict, while the split sets retain every eligible role. The +diagnostic owner maps instead use `setdefault`, keeping the first +`(campaign, role)` for each valid diagnostic hash or event ID. The source +binder pins this syntax. For exact built-in keys and the current *set-valued* +reason output, a first-owner conflict is present precisely when some later +owner differs from the first. A hypothetical last-owner map would flag an +adjacent transition whenever owners are not all equal, so these two rules +produce the same final presence of each conflict reason. The owner map is not +returned. Finite result tests therefore cannot distinguish this internal +first-owner choice in that exact-key domain; the AST binding records it, and +a refinement proof must follow the source rule rather than infer it from +output alone. + +The two diagnostic dimensions are independent. A bad SHA does not enter the +hash owner map, but a valid event ID on the same row still enters the event +owner map. A valid SHA enters its map even if it equals the measurement source +SHA and adds `INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED`. Same-campaign, +same-role reuse is accepted by the child ownership gate. A role change within +one campaign can add split leakage without adding cross-campaign diagnostic +reuse. These are structural reason calculations, not verification of real +diagnostic provenance. + +## Finite evidence and open work + +`tests/test_sonification_formal_mat009_split.py` pins the exact current +MAT009 and MAT008 module SHA-256 values before running independent fabricated +metadata cases. It covers the early result, parent call, campaign cross-split, +lab overlap with three campaigns, both directions of parent/child eligibility +mismatch, parent run/document/byte reasons, independent diagnostic keys, +receipt cardinality, identifier/digest boundaries, subclass and exception +counterexamples, and the exact 14-control ID-to-designated-reason sequence. +It also checks 4,096 four-row exact built-in assignments of role, campaign, +and lab against independent pairwise predicates for the two cross-split reason +IDs. This is finite evidence for those two predicates, not an oracle for every +MAT008 or MAT009 reason. + +The tests are finite observations under the current CPython interpreter. +They do not prove all inputs in the exact built-in domain, the selected AST's +semantics, a Lean model refinement, or physical admission. The CPython bridge +and scientific validation remain **OPEN**. diff --git a/formal/sonification/mat009/source/CONTRACT.md b/formal/sonification/mat009/source/CONTRACT.md new file mode 100644 index 0000000..457f730 --- /dev/null +++ b/formal/sonification/mat009/source/CONTRACT.md @@ -0,0 +1,173 @@ +# Frozen MAT009 challenge source contract + +This document describes `materials/mat_spec_009.py::check_future_challenge` +at annotated tag `mat-spec-009-v0.1.0`. The tag object is +`ad99d9e52f9ede423a4fb9d6a622624e32955263`, its peeled commit is +`0758a96360726aafbb07abed34620eda178407ae`, its tree is +`a6a03e1227e666680d656b886201ee9dde9de32d`, and the module blob and +SHA-256 are `c447f0ce76b91acf458221390ac4261166145a0b` and +`a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690`. +`SOURCE_BINDING.json` and `source_bind.py` check these identities and selected +syntax. They do not establish CPython refinement or physical authenticity. + +The operation is a structural check on asserted metadata. It never trains a +classifier, measures accuracy, authenticates independence, or admits physical +evidence. An empty reason list means only `STRUCTURAL_ONLY_UNAUTHENTICATED`. + +## Exact evaluation order + +1. The outer guard at MAT009 lines 122–129 returns immediately if `records` is + not an `isinstance(..., list)`, is falsey, or has length greater than 10,000. + Its result has exactly `status`, `reasons`, `physical_evidence_admitted`, + `independence_authenticated`, and `heldout_accuracy`. The sole reason is + `EMPTY_OR_MALFORMED_CHALLENGE`. It does not call MAT008 and has no counts, + `trained_classifier`, or `meaning` key. +2. For any list passing that guard, MAT009 calls + `mat_spec_008.validate_future_measurement_packet(records)` once, with the + same object, before any child scan. It initializes `reasons` as a set of + `parent["reasons"]`; it does not inspect the parent's status or counts. + Exceptions from the parent propagate. +3. The child initializes the campaign role map, three split-indexed sets, + valid receipt set, and two diagnostic owner maps empty. It scans rows in + input order. The three early `continue` paths are: non-`dict` row; + `study_role` not equal to either `TRAIN` or `HOLDOUT`; and campaign or lab + failing `_identifier`. A skipped row contributes no child campaign, lab, + phase, diagnostic, receipt, unit, pressure, scale, or label check. The + parent may still have processed that row, because its eligibility differs. +4. An eligible row first checks and then overwrites `split_by_campaign` with + its role. It adds campaign and lab to the selected split sets and adds + `HE_I` or `HE_II` to that split's phase set when recognized. These state + updates happen before unit, pressure, scale, label, diagnostic, and receipt + checks. A later invalid field does not undo them. +5. After the row scan, MAT009 checks the count of distinct valid receipt + digests, presence of both campaign splits, intersection of campaign or lab + sets, and both phases in each split. It sorts the union of parent and child + reason IDs. A nonempty union yields `BLOCKED`; an empty union yields + `STRUCTURAL_ONLY_UNAUTHENTICATED`. + +On the normal path, the result additionally contains `train_campaigns` and +`heldout_campaigns` as set cardinalities, `trained_classifier: false`, and a +fixed `meaning` string. `physical_evidence_admitted` and +`independence_authenticated` are always false, and `heldout_accuracy` is +always null on both result paths. + +## Child checks after the third skip guard + +`_identifier` accepts a `str` or subclass with length at most 100 whose full +text matches `[A-Z0-9_]+`; the `+` rejects empty text. `_digest` accepts a +`str` or subclass matching exactly 64 lowercase hexadecimal characters. +Neither helper requires `type(value) is str`. Subclass behavior is discussed +in `CALLER_DOMAIN.md`. + +| Child reason | Trigger and state detail | +| --- | --- | +| `MALFORMED_CANDIDATE_RECORD` | Row fails `isinstance(record, dict)`; skip. | +| `UNDECLARED_TRAIN_HOLDOUT_ROLE` | Role fails membership in the two literal strings; skip. | +| `MISSING_EXPERIMENT_FAMILY_IDENTITY` | Campaign or lab fails `_identifier`; skip. | +| `CAMPAIGN_CROSSES_TRAIN_HOLDOUT` | The campaign key was already mapped to a different role. The map is then overwritten; both split sets still retain their entries. | +| `INCOMMENSURATE_MEASUREMENT_UNITS` | Quantity is not equal to `HEAT_CAPACITY` or unit is not equal to `J_PER_MOL_K`. | +| `UNDECLARED_PRESSURE_CONDITION` | Pressure is not equal to `HE4_SVP`, even though MAT008 also accepts `DOCUMENTED_FIXED_PRESSURE`. | +| `UNDECLARED_RECEIVER_SCALE` | Scale is not equal to the string `5`. | +| `CIRCULAR_OR_MISSING_ORTHOGONAL_LABEL` | Label basis is not equal to `ORTHOGONAL_DIAGNOSTIC`. | +| `INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED` | Diagnostic SHA is invalid, equals the row's source SHA, or event ID fails `_identifier`. This reason does not skip the ownership loop. | +| `DIAGNOSTIC_PROVENANCE_REUSED_ACROSS_CAMPAIGNS` | A valid diagnostic hash or valid event ID was previously registered with a different campaign key. | +| `DIAGNOSTIC_PROVENANCE_LEAKAGE_ACROSS_SPLITS` | A valid diagnostic hash or valid event ID was previously registered with a different role. This also applies when the campaign key is unchanged but its role changes. | +| `MISSING_PROSPECTIVE_REGISTRATION_RECEIPT` | Receipt fails `_digest`; it is not added to the receipt set. | +| `INCONSISTENT_PREREGISTRATION_RECEIPT` | Final set of valid, eligible receipt digests has cardinality other than one. One invalid receipt among otherwise identical valid receipts adds the missing reason but not this one. | +| `BOTH_EXPERIMENT_SPLITS_REQUIRED` | At least one split has no eligible campaign. | +| `SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS` | Train and holdout campaign sets intersect, or train and holdout lab sets intersect. The two predicates share one reason ID. | +| `TRAIN_REQUIRES_BOTH_PHASES`, `HOLDOUT_REQUIRES_BOTH_PHASES` | The selected split's recognized phase set is not exactly `{HE_I, HE_II}`. | + +The diagnostic loop checks hash and event provenance independently. Its tuple +has the hash first, then event ID. Only a valid identity enters its respective +owner map. `registry.setdefault(identity, (campaign, role))` retains the first +owner seen for that identity. Repeating a diagnostic document or event within +the same campaign and role is allowed by this child gate. A valid diagnostic +hash is registered even when it equals the measurement source hash, and a +valid event ID is registered even when the diagnostic hash is invalid. Other +row errors do not skip this loop. Reason IDs are deduplicated by a set. + +`pre_registration_sha256` is only a syntactic digest assertion. The source +does not inspect receipt contents, timing, signer, or external audit. + +## Direct MAT008 call contract + +The direct parent is `materials/mat_spec_008.py` at blob +`3117adbc3739c834f8203d5d2dd2b80d6caf862b`, SHA-256 +`e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08`. +Its selected operation is lines 228–332. The MAT009 outer guard makes the +parent's empty-packet return unreachable for ordinary exact lists passed +through this call. + +MAT008 scans the same rows before MAT009. It skips a non-`dict` row with +`MALFORMED_CANDIDATE_RECORD`. For a `dict`, it parses campaign, lab, original +run, source document, and row ID in that order with `_identity`. A `ValueError` +from any parse adds `MISSING_OR_INVALID_SOURCE_IDENTITIES` and skips all later +parent checks for that row. `_identity` requires a nonempty `str` or subclass, +length at most 100, no leading or trailing whitespace as judged by `strip` +and equality, and the same full ASCII identifier pattern. For exact built-in +strings, `_identity` and MAT009 `_identifier` accept the same text. However, +MAT009 checks only campaign and lab, so a row with a bad run, document, or row +ID can be parent-skipped and still child-processed. + +After identity acceptance, MAT008 applies these checks and state updates in +the listed order: + +| Parent reason | Condition | +| --- | --- | +| `DUPLICATE_MEASUREMENT_ROW_ID` | Row ID already in `seen_rows`; the set is then updated. | +| `CAMPAIGN_LAB_IDENTITY_CONTRADICTION` | Existing campaign-to-lab mapping differs; map is overwritten. | +| `CAMPAIGN_RUN_OR_DOCUMENT_INCONSISTENT` | Existing campaign-to-`doc:run` mapping differs; map is overwritten. | +| `REUSED_ORIGINAL_RUN_ACROSS_CAMPAIGNS` | Run owner's campaign differs; run owner map is overwritten. | +| `REUSED_ORIGINAL_DOCUMENT_ACROSS_CAMPAIGNS` | Document owner's campaign differs; document owner map is overwritten. | +| `UNVERIFIED_PHASE_LABEL` | Phase is not a `str` or is not `HE_I`/`HE_II`. A non-string becomes `INVALID` in the campaign phase set. | +| `DERIVED_FIT_OR_COMPILATION_IS_NOT_PRIMARY_DATA` | Source type differs from `ORIGINAL_EXPERIMENTAL_RECORD`. | +| `SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT` | `synthetic_fixture is True` by identity. Truthy integer `1` does not trigger it. | +| `CIRCULAR_OR_MISSING_PHASE_DIAGNOSTIC` | Diagnostic basis differs from `INDEPENDENT_NON_TEMPERATURE_DIAGNOSTIC`. | +| `MISSING_CALIBRATED_MEASUREMENT_UNCERTAINTY` | `_decimal` raises `ValueError` on measurement value, measurement sigma, or diagnostic sigma. The first failure short-circuits later numeric parsing. | +| `SOURCE_HASH_OR_PHYSICAL_CONDITION_NOT_DOCUMENTED` | Source SHA is not 64 lowercase hex, or pressure is neither `HE4_SVP` nor `DOCUMENTED_FIXED_PRESSURE`. This branch skips hash ownership checks for that row. | +| `REUSED_SOURCE_BYTES_ACROSS_CAMPAIGNS` | A valid source digest's previous campaign differs; hash owner map is overwritten. | +| `CAMPAIGN_SOURCE_BYTES_INCONSISTENT` | A campaign's previous valid source digest differs; campaign hash map is overwritten. | +| `BOTH_PHASES_REQUIRED_FOR_EACH_CAMPAIGN` | At least one parent-accepted campaign phase set differs from `{HE_I, HE_II}`. | +| `TWO_INDEPENDENT_CAMPAIGNS_AND_LABS_REQUIRED` | Fewer than two distinct campaign keys or fewer than two distinct lab keys were seen. This is a metadata cardinality check, not authentication. | +| `DISTINCT_ORIGINAL_RUNS_REQUIRED` | Fewer than two distinct `doc:run` strings were stored in `experiment_to_source`. Despite its name, this uses document plus run. | + +`_decimal` accepts an exact positive decimal string matching +`(?:0|[1-9][0-9]*)(?:\.[0-9]+)?` and then requires `Fraction(value) > 0`. +MAT008's normal return sorts its reason set and always reports physical +admission and independence authentication as false. MAT009 imports only its +`reasons` list. Neither layer verifies the real-world identity or independence +of a source. + +## Frozen synthetic controls + +`_synthetic_controls()` constructs four in-memory metadata rows: both phases +for `SYNTH_TRAIN`/`SYNTH_LAB_A` and both for +`SYNTH_HELD`/`SYNTH_LAB_B`. Every row has `synthetic_fixture: True`. +`negative_controls()` executes the following 14 mutations, checking that +`BLOCKED`, its designated reason, and the synthetic rejection are present. +It writes no empirical score. Its `observed_rejection` field repeats the +designated reason after a membership check; it is not the complete reason +list, and a mutation can add other reasons. + +| Control ID | Mutation | Designated reason | Layer | +| --- | --- | --- | --- | +| `SYNTHETIC_CANDIDATE_DENIED` | None beyond the synthetic marker | `SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT` | MAT008 | +| `CROSS_CAMPAIGN_RUN_REUSE` | Both heldout run IDs become `SYNTH_RUN_A` | `REUSED_ORIGINAL_RUN_ACROSS_CAMPAIGNS` | MAT008 | +| `CAMPAIGN_SPLIT_LEAKAGE` | Second train phase row changes role to `HOLDOUT` | `CAMPAIGN_CROSSES_TRAIN_HOLDOUT` | MAT009 | +| `SOURCE_BYTES_REUSED` | Both heldout source SHAs become `a` repeated 64 times | `REUSED_SOURCE_BYTES_ACROSS_CAMPAIGNS` | MAT008 | +| `TEMPERATURE_DERIVED_LABEL` | First train row diagnostic basis becomes `TEMPERATURE_THRESHOLD` | `CIRCULAR_OR_MISSING_PHASE_DIAGNOSTIC` | MAT008 | +| `ZERO_MEASUREMENT_SIGMA` | First train row measurement sigma becomes `0` | `MISSING_CALIBRATED_MEASUREMENT_UNCERTAINTY` | MAT008 | +| `ORTHOGONAL_DIAGNOSTIC_ABSENT` | First train row diagnostic SHA becomes null | `INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED` | MAT009 | +| `DIAGNOSTIC_SOURCE_EQUALS_MEASUREMENT` | First train row diagnostic SHA becomes its source SHA | `INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED` | MAT009 | +| `UNDECLARED_RECEIVER_SCALE` | First train row scale becomes `10` | `UNDECLARED_RECEIVER_SCALE` | MAT009 | +| `MISSING_PROSPECTIVE_REGISTRATION` | First train row receipt becomes empty | `MISSING_PROSPECTIVE_REGISTRATION_RECEIPT` | MAT009 | +| `MIXED_PHYSICAL_PRESSURE` | First train row pressure becomes `DOCUMENTED_FIXED_PRESSURE` | `UNDECLARED_PRESSURE_CONDITION` | MAT009 | +| `HOLDOUT_MISSING_PHASE` | Second heldout phase becomes `HE_I`, with a new row ID | `HOLDOUT_REQUIRES_BOTH_PHASES` | MAT009 | +| `DERIVED_FIT_AS_MEASUREMENT` | First train row source type becomes `REANALYSIS` | `DERIVED_FIT_OR_COMPILATION_IS_NOT_PRIMARY_DATA` | MAT008 | +| `DOCUMENT_REUSED` | Both heldout document IDs become `DOC_SYNTH_TRAIN` | `REUSED_ORIGINAL_DOCUMENT_ACROSS_CAMPAIGNS` | MAT008 | + +The 14 controls do not include the separate cross-campaign diagnostic replay +case tested in the frozen MAT009 unit tests and the focused finite checks. +All controls and new finite rows remain synthetic or self-declared metadata; +none supplies an independent physical holdout. diff --git a/formal/sonification/mat009/source/HANDOFF.json b/formal/sonification/mat009/source/HANDOFF.json new file mode 100644 index 0000000..6cf54a1 --- /dev/null +++ b/formal/sonification/mat009/source/HANDOFF.json @@ -0,0 +1,79 @@ +{ + "schema": "sonification-mat009-source-handoff-v1", + "task": "MAT-009-VERIFY-001 source and finite conformance workstream", + "base_commit": "d80f1a09b6f9fd60188148ab20745de5b91462fc", + "branch": "research/sonification-formal-001-mat009-verify", + "source_identity": { + "tag": "mat-spec-009-v0.1.0", + "tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", + "peeled_commit": "0758a96360726aafbb07abed34620eda178407ae", + "tree": "a6a03e1227e666680d656b886201ee9dde9de32d", + "mat009_blob": "c447f0ce76b91acf458221390ac4261166145a0b", + "mat009_sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", + "direct_mat008_blob": "3117adbc3739c834f8203d5d2dd2b80d6caf862b", + "direct_mat008_sha256": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08" + }, + "assurance": { + "source_binding": "SOURCE_SYNTAX_PINNED_ONLY", + "finite_conformance": "PASS_FOR_LISTED_CASES_ONLY", + "cpython_refinement": "OPEN", + "physical_independence_authenticated": false, + "empirical_accuracy_claimed": false + }, + "files_sha256": { + "formal/sonification/mat009/source/SOURCE_BINDING.json": "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91", + "formal/sonification/mat009/source/source_bind.py": "575ab1ea12186419bc6dbae31e12ae1e45d46a3b3c4a630b63e0a53853433beb", + "formal/sonification/mat009/source/CONTRACT.md": "dc8b0eb3035eb36d706b0bdf10be11a6e4abe2170083a1ab389d6f9b26cf6c4d", + "formal/sonification/mat009/source/CALLER_DOMAIN.md": "b57d0eece370b1841f239e45fe989c31def911f2e82e4222b4fa52acb385c0ed", + "tests/test_sonification_formal_mat009_split.py": "beb02ce17f07807309e9cceba2a9e0dd6412dc578cc8362050890f38a5bdad73" + }, + "commands": [ + { + "cwd": "/home/trent/sonification-formal-001-mat009", + "command": "uv run --no-project --offline --with ruff ruff check formal/sonification/mat009/source/source_bind.py tests/test_sonification_formal_mat009_split.py", + "exit_code": 0, + "outcome": "All checks passed!" + }, + { + "cwd": "/home/trent/sonification-formal-001-mat009", + "command": "python3 formal/sonification/mat009/source/source_bind.py", + "exit_code": 0, + "outcome": "SOURCE_SYNTAX_MATCH; selected_functions=8; refinement_to_cpython=OPEN" + }, + { + "cwd": "/home/trent/sonification-formal-001-mat009", + "command": "python3 -m unittest discover -s tests -p test_sonification_formal_mat009_split.py -q", + "exit_code": 0, + "outcome": "Ran 18 tests; OK" + }, + { + "cwd": "/home/trent/sonification-formal-001-mat009", + "command": "python3 -m pytest -q tests/test_sonification_formal_mat009_split.py tests/test_mat_spec_009.py", + "exit_code": 0, + "outcome": "35 passed, 36 subtests passed" + } + ], + "finite_inventory": { + "focused_test_methods": 18, + "exact_builtin_four_row_role_campaign_lab_assignments": 4096, + "pairwise_oracle_reason_ids": [ + "CAMPAIGN_CROSSES_TRAIN_HOLDOUT", + "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + ], + "frozen_synthetic_negative_controls": 14, + "note": "All finite rows and frozen negative controls are fabricated or self-declared metadata, never independent physical measurements." + }, + "retained_counterexamples": [ + "Equal-text str subclass campaign IDs with unequal hashes can return STRUCTURAL_ONLY_UNAUTHENTICATED across TRAIN and HOLDOUT.", + "A dict subclass overriding get can propagate RuntimeError through the MAT008 parent call.", + "An unhashable str subclass row ID can propagate TypeError in MAT008.", + "synthetic_fixture=1 is not synthetic_fixture is True; a structural-only result still admits no physical evidence." + ], + "open_bridge": [ + "No source-to-model theorem proves frozen MAT009 plus direct MAT008 behavior for the exact built-in domain.", + "No theorem covers arbitrary Python subclasses, exceptions, mutation, or monkeypatching.", + "No physical source independence, prospective registration, phase classifier, or empirical holdout has been authenticated." + ], + "production_source_modified": false, + "committed_or_pushed": false +} diff --git a/formal/sonification/mat009/source/SOURCE_BINDING.json b/formal/sonification/mat009/source/SOURCE_BINDING.json new file mode 100644 index 0000000..0880f51 --- /dev/null +++ b/formal/sonification/mat009/source/SOURCE_BINDING.json @@ -0,0 +1,79 @@ +{ + "schema": "sonification-mat009-split-source-binding-v1", + "assurance": "SOURCE_SYNTAX_PINNED_ONLY", + "refinement_to_cpython": "OPEN", + "frozen_release": { + "tag": "refs/tags/mat-spec-009-v0.1.0", + "tag_type": "tag", + "tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", + "peeled_commit": "0758a96360726aafbb07abed34620eda178407ae", + "tree": "a6a03e1227e666680d656b886201ee9dde9de32d" + }, + "target": { + "path": "materials/mat_spec_009.py", + "git_blob": "c447f0ce76b91acf458221390ac4261166145a0b", + "sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", + "bytes": 24623, + "functions": { + "_identifier": { + "start_line": 104, + "end_line": 109, + "ast_source_segment_sha256": "bf63bd67664078f2607e05e811de5ef78779f06839fa03ac40f90f00f2616391" + }, + "_digest": { + "start_line": 112, + "end_line": 113, + "ast_source_segment_sha256": "30c65663c052ae676e95a5b3e42c17d9ebb6539e1ae575511dd5a82ad03ee048" + }, + "check_future_challenge": { + "start_line": 116, + "end_line": 236, + "ast_source_segment_sha256": "fbea7ec4b3d903597ae9e9996c34120570ff12883b183074b15b61225fec48c0" + }, + "_synthetic_controls": { + "start_line": 239, + "end_line": 270, + "ast_source_segment_sha256": "28c87edc176bdb4d2389167cd9e2128747f25c2a3c612f1b15c864f4bb8249bb" + }, + "negative_controls": { + "start_line": 273, + "end_line": 347, + "ast_source_segment_sha256": "2d958f62ddd891dffb06254ab77088b8472413ca1e2bac09198f6dd40d9b2677" + } + } + }, + "direct_parent": { + "path": "materials/mat_spec_008.py", + "git_blob": "3117adbc3739c834f8203d5d2dd2b80d6caf862b", + "sha256": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", + "bytes": 30876, + "functions": { + "_identity": { + "start_line": 69, + "end_line": 75, + "ast_source_segment_sha256": "1ba1775e7b8092aa1ca3addbf761247f5100f266a1d3726a9c1e360483d7f63f" + }, + "_decimal": { + "start_line": 217, + "end_line": 225, + "ast_source_segment_sha256": "f9628dab124e40d9812b05257559d5afa5dd88d8c20f833b20e6ca508a323598" + }, + "validate_future_measurement_packet": { + "start_line": 228, + "end_line": 332, + "ast_source_segment_sha256": "e514874f36bef4f416c4a0fc8c1ee8705e2a6fb8ed15e62fd53f76a1d665660e" + } + } + }, + "selected_call_edge": { + "caller": "materials.mat_spec_009.check_future_challenge", + "callee": "materials.mat_spec_008.validate_future_measurement_packet", + "order": "outer list guard; parent call; parent reason set; child row scan; final checks; sorted normal result", + "parent_invocations_per_accepted_outer_list": 1 + }, + "limitations": [ + "Full module and selected AST identities are pinned; this does not prove source-to-model correspondence or CPython behavior.", + "The MAT008 validator is a direct caller dependency; its transitive import closure and adversarial monkeypatching are outside this slice.", + "All candidate metadata and digests are assertions, not authenticated measurement or preregistration evidence." + ] +} diff --git a/formal/sonification/mat009/source/source_bind.py b/formal/sonification/mat009/source/source_bind.py new file mode 100644 index 0000000..802be33 --- /dev/null +++ b/formal/sonification/mat009/source/source_bind.py @@ -0,0 +1,235 @@ +"""Verify frozen MAT009 split-gate syntax and its direct MAT008 dependency. + +This binder checks Git bytes and selected AST structure. It is not a proof of +CPython semantics, source-to-model refinement, or scientific provenance. +""" + +from __future__ import annotations + +import ast +import hashlib +import json +import subprocess +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] +MANIFEST_SHA256 = "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91" +TAG = "refs/tags/mat-spec-009-v0.1.0" +TAG_OBJECT = "ad99d9e52f9ede423a4fb9d6a622624e32955263" +COMMIT = "0758a96360726aafbb07abed34620eda178407ae" +TREE = "a6a03e1227e666680d656b886201ee9dde9de32d" +TARGET = ( + "materials/mat_spec_009.py", + "c447f0ce76b91acf458221390ac4261166145a0b", + "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", +) +PARENT = ( + "materials/mat_spec_008.py", + "3117adbc3739c834f8203d5d2dd2b80d6caf862b", + "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", +) + + +def require(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def sha256(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def unique_pairs(pairs: list[tuple[str, object]]) -> dict: + result = {} + for key, value in pairs: + require(key not in result, f"duplicate JSON key: {key}") + result[key] = value + return result + + +def git(*arguments: str) -> bytes: + return subprocess.run( + ["git", "-C", str(ROOT), *arguments], + check=True, + capture_output=True, + timeout=30, + ).stdout + + +def one_function(module: ast.Module, name: str) -> ast.FunctionDef: + matches = [ + node for node in module.body + if isinstance(node, ast.FunctionDef) and node.name == name + ] + require(len(matches) == 1, f"expected one top-level function: {name}") + return matches[0] + + +def same_statement(node: ast.AST, expected: str) -> bool: + parsed = ast.parse(expected) + require(len(parsed.body) == 1, "binder expected one statement") + return ast.dump(node, include_attributes=False) == ast.dump( + parsed.body[0], include_attributes=False + ) + + +def spans(raw: bytes, names: set[str]) -> tuple[dict, ast.Module]: + source = raw.decode("utf-8") + module = ast.parse(source) + result = {} + for name in sorted(names): + node = one_function(module, name) + segment = ast.get_source_segment(source, node) + require(segment is not None, f"missing AST source segment: {name}") + result[name] = { + "start_line": node.lineno, + "end_line": node.end_lineno, + "ast_source_segment_sha256": sha256(segment.encode("utf-8")), + } + return result, module + + +def require_selected_ast_shape(target: ast.Module, parent: ast.Module) -> None: + """Check the small interpretation inventory used by the source contract.""" + child = one_function(target, "check_future_challenge") + require(len(child.body) == 18, "child top-level statement inventory changed") + require(isinstance(child.body[1], ast.If) + and ast.dump(child.body[1].test, include_attributes=False) + == ast.dump(ast.parse( + "not isinstance(records, list) or not records or len(records) > 10000", + mode="eval", + ).body, include_attributes=False), + "child outer guard changed") + require(same_statement( + child.body[2], + "parent = mat_spec_008.validate_future_measurement_packet(records)", + ), "MAT008 parent call changed") + require(same_statement( + child.body[3], 'reasons = set(parent["reasons"])', + ), "MAT008 reason union initialization changed") + row_loop = child.body[11] + require(isinstance(row_loop, ast.For) and isinstance(row_loop.iter, ast.Name) + and row_loop.iter.id == "records" and len(row_loop.body) == 22, + "child row-loop inventory changed") + for index, expected in ( + (0, '''if not isinstance(record, dict): + reasons.add("MALFORMED_CANDIDATE_RECORD") + continue'''), + (2, '''if role not in ("TRAIN", "HOLDOUT"): + reasons.add("UNDECLARED_TRAIN_HOLDOUT_ROLE") + continue'''), + (4, '''if not _identifier(campaign) or not _identifier(lab): + reasons.add("MISSING_EXPERIMENT_FAMILY_IDENTITY") + continue'''), + ): + require(same_statement(row_loop.body[index], expected), + f"child skip guard {index} changed") + require(same_statement(row_loop.body[19], '''for identity, registry, valid in ( + (diagnostic_hash, diagnostic_hash_owners, _digest(diagnostic_hash)), + (diagnostic_event_id, diagnostic_event_owners, _identifier(diagnostic_event_id)), +): + if not valid: + continue + prior = registry.setdefault(identity, (campaign, role)) + if prior[0] != campaign: + reasons.add("DIAGNOSTIC_PROVENANCE_REUSED_ACROSS_CAMPAIGNS") + if prior[1] != role: + reasons.add("DIAGNOSTIC_PROVENANCE_LEAKAGE_ACROSS_SPLITS")'''), + "diagnostic first-owner gate changed") + require(same_statement(child.body[16], "outcome = sorted(reasons)"), + "normal reason sorting changed") + require(isinstance(child.body[17], ast.Return) + and isinstance(child.body[17].value, ast.Dict), + "normal result shape changed") + normal_keys = [ + key.value for key in child.body[17].value.keys + if isinstance(key, ast.Constant) + ] + require(normal_keys == [ + "status", "reasons", "train_campaigns", "heldout_campaigns", + "physical_evidence_admitted", "independence_authenticated", + "heldout_accuracy", "trained_classifier", "meaning", + ], "normal result keys changed") + father = one_function(parent, "validate_future_measurement_packet") + require(isinstance(father.body[13], ast.For) + and isinstance(father.body[13].iter, ast.Name) + and father.body[13].iter.id == "records", "parent row loop changed") + require(same_statement(father.body[13].body[0], '''if not isinstance(row, dict): + reasons.add("MALFORMED_CANDIDATE_RECORD") + continue'''), "parent row type guard changed") + require(same_statement(father.body[13].body[1], '''try: + camp = _identity(row.get("campaign_id")) + lab = _identity(row.get("lab_family_id")) + run = _identity(row.get("original_run_id")) + doc = _identity(row.get("source_document_id")) + identifier = _identity(row.get("row_id")) +except ValueError: + reasons.add("MISSING_OR_INVALID_SOURCE_IDENTITIES") + continue'''), "parent identity skip guard changed") + + +def verify() -> dict: + manifest_bytes = (HERE / "SOURCE_BINDING.json").read_bytes() + require(sha256(manifest_bytes) == MANIFEST_SHA256, + "MAT009 source binding manifest changed") + manifest = json.loads(manifest_bytes, object_pairs_hook=unique_pairs) + require(manifest["assurance"] == "SOURCE_SYNTAX_PINNED_ONLY" + and manifest["refinement_to_cpython"] == "OPEN", + "source binding assurance changed") + require(manifest["frozen_release"] == { + "tag": TAG, + "tag_type": "tag", + "tag_object": TAG_OBJECT, + "peeled_commit": COMMIT, + "tree": TREE, + }, "frozen tag identity changed") + require(git("cat-file", "-t", TAG).strip() == b"tag", + "MAT009 release tag is not annotated") + for ref, expected in ( + (TAG, TAG_OBJECT), + (TAG + "^{commit}", COMMIT), + (TAG + "^{tree}", TREE), + ): + require(git("rev-parse", ref).decode("ascii").strip() == expected, + f"frozen Git identity mismatch: {ref}") + parsed = {} + for label, pinned in (("target", TARGET), ("direct_parent", PARENT)): + path, blob, digest = pinned + record = manifest[label] + require((record["path"], record["git_blob"], record["sha256"]) + == pinned, f"{label} manifest identity changed") + frozen_blob = git("rev-parse", f"{COMMIT}:{path}").decode("ascii").strip() + frozen_raw = git("show", f"{COMMIT}:{path}") + require(frozen_blob == blob and sha256(frozen_raw) == digest + and len(frozen_raw) == record["bytes"], + f"frozen {label} bytes changed") + require((ROOT / path).read_bytes() == frozen_raw, + f"working-tree {label} differs from frozen release") + computed, parsed[label] = spans(frozen_raw, set(record["functions"])) + require(computed == record["functions"], f"{label} AST spans changed") + require_selected_ast_shape(parsed["target"], parsed["direct_parent"]) + require(manifest["selected_call_edge"] == { + "caller": "materials.mat_spec_009.check_future_challenge", + "callee": "materials.mat_spec_008.validate_future_measurement_packet", + "order": ( + "outer list guard; parent call; parent reason set; child row scan; " + "final checks; sorted normal result" + ), + "parent_invocations_per_accepted_outer_list": 1, + }, "selected call edge description changed") + return { + "status": "SOURCE_SYNTAX_MATCH", + "assurance": "SOURCE_SYNTAX_PINNED_ONLY", + "refinement_to_cpython": "OPEN", + "tag_object": TAG_OBJECT, + "commit": COMMIT, + "tree": TREE, + "target_sha256": TARGET[2], + "direct_parent_sha256": PARENT[2], + "selected_functions": 8, + } + + +if __name__ == "__main__": + print(json.dumps(verify(), sort_keys=True)) diff --git a/tests/test_sonification_formal_mat009_split.py b/tests/test_sonification_formal_mat009_split.py new file mode 100644 index 0000000..9efc662 --- /dev/null +++ b/tests/test_sonification_formal_mat009_split.py @@ -0,0 +1,423 @@ +"""Finite, source-pinned checks of the MAT009 split gate. + +All rows below are fabricated, self-declared metadata. A structural pass is +never physical admission, source authentication, or an empirical score. +""" + +from __future__ import annotations + +import hashlib +import unittest +from itertools import combinations, product +from pathlib import Path +from unittest.mock import patch + +from materials import mat_spec_008, mat_spec_009 + +ROOT = Path(__file__).resolve().parents[1] +MAT009_SHA256 = "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690" +MAT008_SHA256 = "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08" + + +def self_declared_rows( + campaigns: tuple[tuple[str, str, str], ...] = ( + ("CAMP_A", "LAB_A", "TRAIN"), + ("CAMP_B", "LAB_B", "HOLDOUT"), + ), +) -> list[dict]: + """Make independent fake metadata, without using production fixtures.""" + rows: list[dict] = [] + for index, (campaign, lab, role) in enumerate(campaigns): + source = "abcd"[index] * 64 + diagnostic = "5678"[index] * 64 + for phase in ("HE_I", "HE_II"): + rows.append({ + "row_id": f"ROW_{index}_{phase}", + "campaign_id": campaign, + "lab_family_id": lab, + "original_run_id": f"RUN_{index}", + "source_document_id": f"DOC_{index}", + "source_sha256": source, + "diagnostic_sha256": diagnostic, + "diagnostic_event_id": f"DIAG_{index}_{phase}", + "source_type": "ORIGINAL_EXPERIMENTAL_RECORD", + "measurement_quantity": "HEAT_CAPACITY", + "measurement_unit": "J_PER_MOL_K", + "measurement_value": "12.34", + "measurement_sigma": "0.01", + "diagnostic_sigma": "0.02", + "diagnostic_basis": "INDEPENDENT_NON_TEMPERATURE_DIAGNOSTIC", + "label_basis": "ORTHOGONAL_DIAGNOSTIC", + "phase": phase, + "receiver_scale": "5", + "pre_registration_sha256": "f" * 64, + "pressure_condition": "HE4_SVP", + "study_role": role, + }) + return rows + + +class DivergentHashString(str): + """Equal text with unequal hashes violates the built-in string contract.""" + + def __new__(cls, value: str, assigned_hash: int) -> DivergentHashString: + instance = str.__new__(cls, value) + instance.assigned_hash = assigned_hash + return instance + + def __hash__(self) -> int: + return self.assigned_hash + + +class UnhashableString(str): + __hash__ = None + + +class ExplodingDict(dict): + def get(self, key: object, default: object = None) -> object: + raise RuntimeError("dict subclass get failed") + + +class SplitGateFiniteTests(unittest.TestCase): + @classmethod + def setUpClass(cls) -> None: + for path, expected in ( + ("materials/mat_spec_009.py", MAT009_SHA256), + ("materials/mat_spec_008.py", MAT008_SHA256), + ): + observed = hashlib.sha256((ROOT / path).read_bytes()).hexdigest() + if observed != expected: + raise AssertionError(f"frozen source drift: {path}: {observed}") + + def assert_no_physical_claim(self, result: dict) -> None: + self.assertIs(result["physical_evidence_admitted"], False) + self.assertIs(result["independence_authenticated"], False) + self.assertIsNone(result["heldout_accuracy"]) + + def test_self_declared_builtins_pass_structure_only(self) -> None: + rows = self_declared_rows() + with patch.object( + mat_spec_008, + "validate_future_measurement_packet", + wraps=mat_spec_008.validate_future_measurement_packet, + ) as parent_call: + result = mat_spec_009.check_future_challenge(rows) + self.assertEqual(parent_call.call_count, 1) + self.assertEqual(result["status"], "STRUCTURAL_ONLY_UNAUTHENTICATED") + self.assertEqual(result["reasons"], []) + self.assertEqual((result["train_campaigns"], result["heldout_campaigns"]), (1, 1)) + self.assertIs(result["trained_classifier"], False) + self.assert_no_physical_claim(result) + + def test_outer_guard_returns_before_parent_with_short_result(self) -> None: + expected = { + "status": "BLOCKED", + "reasons": ["EMPTY_OR_MALFORMED_CHALLENGE"], + "physical_evidence_admitted": False, + "independence_authenticated": False, + "heldout_accuracy": None, + } + for bad in (None, (), {}, [], [{}] * 10001): + length = len(bad) if bad is not None else None + with ( + self.subTest(kind=type(bad).__name__, length=length), + patch.object( + mat_spec_008, + "validate_future_measurement_packet", + side_effect=AssertionError("parent must not run"), + ), + ): + self.assertEqual(mat_spec_009.check_future_challenge(bad), expected) + + def test_campaign_cross_split_is_sticky_in_both_row_orders(self) -> None: + for reversed_order in (False, True): + rows = self_declared_rows() + rows[1]["study_role"] = "HOLDOUT" + if reversed_order: + rows.reverse() + result = mat_spec_009.check_future_challenge(rows) + self.assertEqual(result["status"], "BLOCKED") + self.assertEqual(result["reasons"], sorted({ + "CAMPAIGN_CROSSES_TRAIN_HOLDOUT", + "DIAGNOSTIC_PROVENANCE_LEAKAGE_ACROSS_SPLITS", + "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS", + "TRAIN_REQUIRES_BOTH_PHASES", + })) + self.assert_no_physical_claim(result) + + def test_lab_overlap_blocks_distinct_campaigns_without_parent_reason(self) -> None: + rows = self_declared_rows(( + ("CAMP_A", "LAB_A", "TRAIN"), + ("CAMP_B", "LAB_B", "TRAIN"), + ("CAMP_C", "LAB_A", "HOLDOUT"), + )) + self.assertEqual(mat_spec_008.validate_future_measurement_packet(rows)["reasons"], []) + result = mat_spec_009.check_future_challenge(rows) + self.assertEqual(result["reasons"], ["SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS"]) + self.assertEqual((result["train_campaigns"], result["heldout_campaigns"]), (2, 1)) + self.assert_no_physical_claim(result) + + def test_small_builtin_split_domain_matches_pairwise_oracle(self) -> None: + """Compare map/set outcomes with independent row-pair relations.""" + roles = ("TRAIN", "HOLDOUT") + campaigns = ("CAMP_A", "CAMP_B") + labs = ("LAB_A", "LAB_B") + for chosen_roles in product(roles, repeat=4): + for chosen_campaigns in product(campaigns, repeat=4): + for chosen_labs in product(labs, repeat=4): + rows = self_declared_rows() + for index, row in enumerate(rows): + row["study_role"] = chosen_roles[index] + row["campaign_id"] = chosen_campaigns[index] + row["lab_family_id"] = chosen_labs[index] + reasons = mat_spec_009.check_future_challenge(rows)["reasons"] + pairs = tuple(combinations(range(4), 2)) + cross_campaign = any( + chosen_roles[i] != chosen_roles[j] + and chosen_campaigns[i] == chosen_campaigns[j] + for i, j in pairs + ) + shared_family = any( + chosen_roles[i] != chosen_roles[j] + and ( + chosen_campaigns[i] == chosen_campaigns[j] + or chosen_labs[i] == chosen_labs[j] + ) + for i, j in pairs + ) + self.assertEqual( + "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" in reasons, + cross_campaign, + ) + self.assertEqual( + "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" in reasons, + shared_family, + ) + self.assertEqual(reasons, sorted(set(reasons))) + + def test_invalid_role_skips_later_child_fields_but_parent_runs(self) -> None: + rows = self_declared_rows() + rows[0].update({ + "study_role": "UNDECLARED", + "measurement_unit": "WRONG", + "receiver_scale": "10", + "diagnostic_sha256": None, + "pre_registration_sha256": "", + }) + self.assertEqual(mat_spec_008.validate_future_measurement_packet(rows)["reasons"], []) + result = mat_spec_009.check_future_challenge(rows) + self.assertEqual(result["reasons"], [ + "TRAIN_REQUIRES_BOTH_PHASES", "UNDECLARED_TRAIN_HOLDOUT_ROLE", + ]) + self.assert_no_physical_claim(result) + + def test_invalid_family_skips_later_child_fields_and_parent_row(self) -> None: + rows = self_declared_rows() + rows[0].update({ + "campaign_id": "", + "measurement_unit": "WRONG", + "receiver_scale": "10", + "diagnostic_sha256": None, + "pre_registration_sha256": "", + }) + result = mat_spec_009.check_future_challenge(rows) + self.assertEqual(result["reasons"], sorted({ + "BOTH_PHASES_REQUIRED_FOR_EACH_CAMPAIGN", + "MISSING_EXPERIMENT_FAMILY_IDENTITY", + "MISSING_OR_INVALID_SOURCE_IDENTITIES", + "TRAIN_REQUIRES_BOTH_PHASES", + })) + self.assert_no_physical_claim(result) + + def test_parent_only_identity_skip_still_allows_child_split_row(self) -> None: + rows = self_declared_rows() + rows[0]["original_run_id"] = "" + parent = mat_spec_008.validate_future_measurement_packet(rows) + self.assertEqual(parent["reasons"], [ + "BOTH_PHASES_REQUIRED_FOR_EACH_CAMPAIGN", + "MISSING_OR_INVALID_SOURCE_IDENTITIES", + ]) + result = mat_spec_009.check_future_challenge(rows) + self.assertEqual(result["reasons"], parent["reasons"]) + self.assertEqual((result["train_campaigns"], result["heldout_campaigns"]), (1, 1)) + self.assertNotIn("TRAIN_REQUIRES_BOTH_PHASES", result["reasons"]) + self.assert_no_physical_claim(result) + + def test_parent_run_document_and_byte_reasons_survive_union(self) -> None: + cases = ( + ("original_run_id", "REUSED_ORIGINAL_RUN_ACROSS_CAMPAIGNS"), + ("source_document_id", "REUSED_ORIGINAL_DOCUMENT_ACROSS_CAMPAIGNS"), + ("source_sha256", "REUSED_SOURCE_BYTES_ACROSS_CAMPAIGNS"), + ) + for field, reason in cases: + with self.subTest(field=field): + rows = self_declared_rows() + for row in rows[2:]: + row[field] = rows[0][field] + self.assertEqual( + mat_spec_008.validate_future_measurement_packet(rows)["reasons"], + [reason], + ) + result = mat_spec_009.check_future_challenge(rows) + self.assertEqual(result["reasons"], [reason]) + self.assert_no_physical_claim(result) + + def test_diagnostic_hash_and_event_are_independent_ownership_keys(self) -> None: + for field in ("diagnostic_sha256", "diagnostic_event_id"): + with self.subTest(field=field): + rows = self_declared_rows() + rows[2][field] = rows[0][field] + result = mat_spec_009.check_future_challenge(rows) + self.assertEqual(result["reasons"], [ + "DIAGNOSTIC_PROVENANCE_LEAKAGE_ACROSS_SPLITS", + "DIAGNOSTIC_PROVENANCE_REUSED_ACROSS_CAMPAIGNS", + ]) + self.assert_no_physical_claim(result) + + def test_same_campaign_diagnostic_document_and_event_reuse_is_allowed(self) -> None: + rows = self_declared_rows() + rows[1]["diagnostic_event_id"] = rows[0]["diagnostic_event_id"] + result = mat_spec_009.check_future_challenge(rows) + self.assertEqual(result["reasons"], []) + self.assertEqual(result["status"], "STRUCTURAL_ONLY_UNAUTHENTICATED") + self.assert_no_physical_claim(result) + + def test_invalid_diagnostic_key_is_not_registered_other_key_still_is(self) -> None: + for field, bad in (("diagnostic_sha256", None), ("diagnostic_event_id", "bad")): + with self.subTest(field=field): + rows = self_declared_rows() + rows[0][field] = bad + rows[2][field] = bad + result = mat_spec_009.check_future_challenge(rows) + self.assertEqual(result["reasons"], ["INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED"]) + rows = self_declared_rows() + rows[0]["diagnostic_sha256"] = None + rows[2]["diagnostic_sha256"] = None + rows[2]["diagnostic_event_id"] = rows[0]["diagnostic_event_id"] + result = mat_spec_009.check_future_challenge(rows) + self.assertEqual(result["reasons"], [ + "DIAGNOSTIC_PROVENANCE_LEAKAGE_ACROSS_SPLITS", + "DIAGNOSTIC_PROVENANCE_REUSED_ACROSS_CAMPAIGNS", + "INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED", + ]) + self.assert_no_physical_claim(result) + + def test_receipt_set_counts_only_valid_unskipped_digests(self) -> None: + rows = self_declared_rows() + rows[0]["pre_registration_sha256"] = "" + self.assertEqual(mat_spec_009.check_future_challenge(rows)["reasons"], [ + "MISSING_PROSPECTIVE_REGISTRATION_RECEIPT", + ]) + rows = self_declared_rows() + rows[0]["pre_registration_sha256"] = "0" * 64 + self.assertEqual(mat_spec_009.check_future_challenge(rows)["reasons"], [ + "INCONSISTENT_PREREGISTRATION_RECEIPT", + ]) + rows = self_declared_rows() + for row in rows: + row["pre_registration_sha256"] = "" + self.assertEqual(mat_spec_009.check_future_challenge(rows)["reasons"], [ + "INCONSISTENT_PREREGISTRATION_RECEIPT", + "MISSING_PROSPECTIVE_REGISTRATION_RECEIPT", + ]) + + def test_identifier_and_digest_are_ascii_boundaries(self) -> None: + for accepted in ("A", "_", "0", "A" * 100, DivergentHashString("ABC", 1)): + self.assertTrue(mat_spec_009._identifier(accepted)) + for rejected in ("", "A" * 101, "a", "É", " A", "A\n", None, 7): + self.assertFalse(mat_spec_009._identifier(rejected)) + self.assertTrue(mat_spec_009._digest("a" * 64)) + self.assertTrue(mat_spec_009._digest(DivergentHashString("a" * 64, 1))) + for rejected in ("A" * 64, "a" * 63, "g" * 64, None): + self.assertFalse(mat_spec_009._digest(rejected)) + + def test_equal_text_str_subclass_hashes_can_evade_split_detection(self) -> None: + first = DivergentHashString("SAME_CAMP", 11) + second = DivergentHashString("SAME_CAMP", 23) + self.assertEqual(first, second) + self.assertNotEqual(hash(first), hash(second)) + rows = self_declared_rows() + for row in rows[:2]: + row["campaign_id"] = first + for row in rows[2:]: + row["campaign_id"] = second + observed = mat_spec_009.check_future_challenge(rows) + self.assertEqual(observed["reasons"], []) + self.assertEqual(observed["status"], "STRUCTURAL_ONLY_UNAUTHENTICATED") + self.assert_no_physical_claim(observed) + for row in rows: + row["campaign_id"] = "SAME_CAMP" + builtins_observed = mat_spec_009.check_future_challenge(rows) + self.assertIn("CAMPAIGN_CROSSES_TRAIN_HOLDOUT", builtins_observed["reasons"]) + self.assertIn("SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS", builtins_observed["reasons"]) + self.assert_no_physical_claim(builtins_observed) + + def test_subclass_methods_and_unhashable_identifiers_can_raise(self) -> None: + class ListSubclass(list): + pass + + class DictSubclass(dict): + pass + + rows = ListSubclass(DictSubclass(row) for row in self_declared_rows()) + self.assertEqual( + mat_spec_009.check_future_challenge(rows)["status"], + "STRUCTURAL_ONLY_UNAUTHENTICATED", + ) + rows = self_declared_rows() + rows[0] = ExplodingDict(rows[0]) + with self.assertRaisesRegex(RuntimeError, "dict subclass get failed"): + mat_spec_009.check_future_challenge(rows) + rows = self_declared_rows() + rows[0]["row_id"] = UnhashableString("ROW_0_HE_I") + with self.assertRaises(TypeError): + mat_spec_009.check_future_challenge(rows) + + def test_synthetic_flag_uses_identity_and_never_admits_physics(self) -> None: + rows = self_declared_rows() + for row in rows: + row["synthetic_fixture"] = True + marked = mat_spec_009.check_future_challenge(rows) + self.assertEqual(marked["reasons"], [ + "SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT", + ]) + self.assert_no_physical_claim(marked) + for row in rows: + row["synthetic_fixture"] = 1 + truthy_integer = mat_spec_009.check_future_challenge(rows) + self.assertEqual(truthy_integer["reasons"], []) + self.assertEqual(truthy_integer["status"], "STRUCTURAL_ONLY_UNAUTHENTICATED") + self.assert_no_physical_claim(truthy_integer) + + def test_fourteen_frozen_negative_controls_are_synthetic_only(self) -> None: + expected = ( + ("SYNTHETIC_CANDIDATE_DENIED", "SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT"), + ("CROSS_CAMPAIGN_RUN_REUSE", "REUSED_ORIGINAL_RUN_ACROSS_CAMPAIGNS"), + ("CAMPAIGN_SPLIT_LEAKAGE", "CAMPAIGN_CROSSES_TRAIN_HOLDOUT"), + ("SOURCE_BYTES_REUSED", "REUSED_SOURCE_BYTES_ACROSS_CAMPAIGNS"), + ("TEMPERATURE_DERIVED_LABEL", "CIRCULAR_OR_MISSING_PHASE_DIAGNOSTIC"), + ("ZERO_MEASUREMENT_SIGMA", "MISSING_CALIBRATED_MEASUREMENT_UNCERTAINTY"), + ("ORTHOGONAL_DIAGNOSTIC_ABSENT", "INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED"), + ("DIAGNOSTIC_SOURCE_EQUALS_MEASUREMENT", "INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED"), + ("UNDECLARED_RECEIVER_SCALE", "UNDECLARED_RECEIVER_SCALE"), + ("MISSING_PROSPECTIVE_REGISTRATION", "MISSING_PROSPECTIVE_REGISTRATION_RECEIPT"), + ("MIXED_PHYSICAL_PRESSURE", "UNDECLARED_PRESSURE_CONDITION"), + ("HOLDOUT_MISSING_PHASE", "HOLDOUT_REQUIRES_BOTH_PHASES"), + ("DERIVED_FIT_AS_MEASUREMENT", "DERIVED_FIT_OR_COMPILATION_IS_NOT_PRIMARY_DATA"), + ("DOCUMENT_REUSED", "REUSED_ORIGINAL_DOCUMENT_ACROSS_CAMPAIGNS"), + ) + controls = mat_spec_009.negative_controls() + self.assertEqual(tuple( + (row["control_id"], row["expected_rejection"]) for row in controls + ), expected) + self.assertEqual(tuple(row["control_id"] for row in controls), mat_spec_009.CONTROL_IDS) + for row in controls: + self.assertEqual(row["observed_rejection"], row["expected_rejection"]) + self.assertEqual(row["result"], "PASS_REJECTED") + self.assertEqual(row["synthetic_only"], "true") + self.assertEqual(row["physical_evidence_admitted"], "false") + self.assertEqual(row["classifier_accuracy"], "NULL") + + +if __name__ == "__main__": + unittest.main() From 481ca587ef2dfe7683aecc9cdd9a1524bb0cb6be Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:23:03 +1030 Subject: [PATCH 02/22] formal(mat009): retain source and finite execution receipts --- .../evidence/mat009-finite-001/receipt.json | 36 ++++++++++++++++++ .../evidence/mat009-finite-001/stderr.log | 4 ++ .../evidence/mat009-finite-001/stdout.log | 0 .../mat009-finite-001/tracked-diff.patch | 0 .../mat009-finite-001/worktree-status.txt | 2 + .../evidence/mat009-pytest-001/receipt.json | 34 +++++++++++++++++ .../evidence/mat009-pytest-001/stderr.log | 0 .../evidence/mat009-pytest-001/stdout.log | 2 + .../mat009-pytest-001/tracked-diff.patch | 0 .../mat009-pytest-001/worktree-status.txt | 4 ++ .../mat009-ruff-source-001/receipt.json | 37 +++++++++++++++++++ .../mat009-ruff-source-001/stderr.log | 0 .../mat009-ruff-source-001/stdout.log | 1 + .../mat009-ruff-source-001/tracked-diff.patch | 0 .../worktree-status.txt | 3 ++ .../mat009-source-bind-001/receipt.json | 29 +++++++++++++++ .../mat009-source-bind-001/stderr.log | 0 .../mat009-source-bind-001/stdout.log | 1 + .../mat009-source-bind-001/tracked-diff.patch | 0 .../worktree-status.txt | 0 20 files changed, 153 insertions(+) create mode 100644 formal/sonification/evidence/mat009-finite-001/receipt.json create mode 100644 formal/sonification/evidence/mat009-finite-001/stderr.log create mode 100644 formal/sonification/evidence/mat009-finite-001/stdout.log create mode 100644 formal/sonification/evidence/mat009-finite-001/tracked-diff.patch create mode 100644 formal/sonification/evidence/mat009-finite-001/worktree-status.txt create mode 100644 formal/sonification/evidence/mat009-pytest-001/receipt.json create mode 100644 formal/sonification/evidence/mat009-pytest-001/stderr.log create mode 100644 formal/sonification/evidence/mat009-pytest-001/stdout.log create mode 100644 formal/sonification/evidence/mat009-pytest-001/tracked-diff.patch create mode 100644 formal/sonification/evidence/mat009-pytest-001/worktree-status.txt create mode 100644 formal/sonification/evidence/mat009-ruff-source-001/receipt.json create mode 100644 formal/sonification/evidence/mat009-ruff-source-001/stderr.log create mode 100644 formal/sonification/evidence/mat009-ruff-source-001/stdout.log create mode 100644 formal/sonification/evidence/mat009-ruff-source-001/tracked-diff.patch create mode 100644 formal/sonification/evidence/mat009-ruff-source-001/worktree-status.txt create mode 100644 formal/sonification/evidence/mat009-source-bind-001/receipt.json create mode 100644 formal/sonification/evidence/mat009-source-bind-001/stderr.log create mode 100644 formal/sonification/evidence/mat009-source-bind-001/stdout.log create mode 100644 formal/sonification/evidence/mat009-source-bind-001/tracked-diff.patch create mode 100644 formal/sonification/evidence/mat009-source-bind-001/worktree-status.txt diff --git a/formal/sonification/evidence/mat009-finite-001/receipt.json b/formal/sonification/evidence/mat009-finite-001/receipt.json new file mode 100644 index 0000000..3a6b9c8 --- /dev/null +++ b/formal/sonification/evidence/mat009-finite-001/receipt.json @@ -0,0 +1,36 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_sonification_formal_mat009_split.py", + "-q" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:52:28.982815+00:00", + "ended_utc": "2026-11-10T00:52:29.350500+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "DIRTY", + "inputs": { + "tests/test_sonification_formal_mat009_split.py": "beb02ce17f07807309e9cceba2a9e0dd6412dc578cc8362050890f38a5bdad73", + "formal/sonification/mat009/source/SOURCE_BINDING.json": "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_sha256": "a9483ce54e9021f19fa52d97950324449ba5ca38db4a3470dd71bef8a85d2de7", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/evidence/mat009-finite-001/stderr.log b/formal/sonification/evidence/mat009-finite-001/stderr.log new file mode 100644 index 0000000..591f368 --- /dev/null +++ b/formal/sonification/evidence/mat009-finite-001/stderr.log @@ -0,0 +1,4 @@ +---------------------------------------------------------------------- +Ran 18 tests in 0.303s + +OK diff --git a/formal/sonification/evidence/mat009-finite-001/stdout.log b/formal/sonification/evidence/mat009-finite-001/stdout.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-finite-001/tracked-diff.patch b/formal/sonification/evidence/mat009-finite-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-finite-001/worktree-status.txt b/formal/sonification/evidence/mat009-finite-001/worktree-status.txt new file mode 100644 index 0000000..9c54d09 --- /dev/null +++ b/formal/sonification/evidence/mat009-finite-001/worktree-status.txt @@ -0,0 +1,2 @@ +?? formal/sonification/evidence/mat009-source-bind-001/ +?? formal/sonification/mat009/lean/ diff --git a/formal/sonification/evidence/mat009-pytest-001/receipt.json b/formal/sonification/evidence/mat009-pytest-001/receipt.json new file mode 100644 index 0000000..813b10b --- /dev/null +++ b/formal/sonification/evidence/mat009-pytest-001/receipt.json @@ -0,0 +1,34 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "-m", + "pytest", + "-q", + "tests/test_sonification_formal_mat009_split.py", + "tests/test_mat_spec_009.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:52:36.645752+00:00", + "ended_utc": "2026-11-10T00:52:54.847548+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "DIRTY", + "inputs": { + "tests/test_sonification_formal_mat009_split.py": "beb02ce17f07807309e9cceba2a9e0dd6412dc578cc8362050890f38a5bdad73", + "tests/test_mat_spec_009.py": "b6041d67615c4203d435250bdc97403e61ca371e0c8f20f8abdeda69251ccbf8", + "formal/sonification/mat009/source/SOURCE_BINDING.json": "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "d9cc08981d877d35bc68dd5572cb02a6c909d5ee70d9539d37aef89383b86bff", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/evidence/mat009-pytest-001/stderr.log b/formal/sonification/evidence/mat009-pytest-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-pytest-001/stdout.log b/formal/sonification/evidence/mat009-pytest-001/stdout.log new file mode 100644 index 0000000..4813857 --- /dev/null +++ b/formal/sonification/evidence/mat009-pytest-001/stdout.log @@ -0,0 +1,2 @@ +................................... [100%] +35 passed, 36 subtests passed in 18.01s diff --git a/formal/sonification/evidence/mat009-pytest-001/tracked-diff.patch b/formal/sonification/evidence/mat009-pytest-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-pytest-001/worktree-status.txt b/formal/sonification/evidence/mat009-pytest-001/worktree-status.txt new file mode 100644 index 0000000..40e4879 --- /dev/null +++ b/formal/sonification/evidence/mat009-pytest-001/worktree-status.txt @@ -0,0 +1,4 @@ +?? formal/sonification/evidence/mat009-finite-001/ +?? formal/sonification/evidence/mat009-ruff-source-001/ +?? formal/sonification/evidence/mat009-source-bind-001/ +?? formal/sonification/mat009/lean/ diff --git a/formal/sonification/evidence/mat009-ruff-source-001/receipt.json b/formal/sonification/evidence/mat009-ruff-source-001/receipt.json new file mode 100644 index 0000000..9566d9d --- /dev/null +++ b/formal/sonification/evidence/mat009-ruff-source-001/receipt.json @@ -0,0 +1,37 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "uv", + "run", + "--no-project", + "--offline", + "--with", + "ruff", + "ruff", + "check", + "formal/sonification/mat009/source/source_bind.py", + "tests/test_sonification_formal_mat009_split.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:52:33.144223+00:00", + "ended_utc": "2026-11-10T00:52:33.170994+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "DIRTY", + "inputs": { + "formal/sonification/mat009/source/source_bind.py": "575ab1ea12186419bc6dbae31e12ae1e45d46a3b3c4a630b63e0a53853433beb", + "tests/test_sonification_formal_mat009_split.py": "beb02ce17f07807309e9cceba2a9e0dd6412dc578cc8362050890f38a5bdad73" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/home/trent/.local/bin/uv", + "command_executable_sha256": "92face6b1f0462ad911857957bd168cd4ae45515e2a2cb3fcc3ecbda3d4d82b1", + "stdout_sha256": "82b3e6a6c090a57601d22943bd23fca9218d1031dbe5a7b754092f9a156b4f18", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/evidence/mat009-ruff-source-001/stderr.log b/formal/sonification/evidence/mat009-ruff-source-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-ruff-source-001/stdout.log b/formal/sonification/evidence/mat009-ruff-source-001/stdout.log new file mode 100644 index 0000000..1f5f344 --- /dev/null +++ b/formal/sonification/evidence/mat009-ruff-source-001/stdout.log @@ -0,0 +1 @@ +All checks passed! diff --git a/formal/sonification/evidence/mat009-ruff-source-001/tracked-diff.patch b/formal/sonification/evidence/mat009-ruff-source-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-ruff-source-001/worktree-status.txt b/formal/sonification/evidence/mat009-ruff-source-001/worktree-status.txt new file mode 100644 index 0000000..f6c6f53 --- /dev/null +++ b/formal/sonification/evidence/mat009-ruff-source-001/worktree-status.txt @@ -0,0 +1,3 @@ +?? formal/sonification/evidence/mat009-finite-001/ +?? formal/sonification/evidence/mat009-source-bind-001/ +?? formal/sonification/mat009/lean/ diff --git a/formal/sonification/evidence/mat009-source-bind-001/receipt.json b/formal/sonification/evidence/mat009-source-bind-001/receipt.json new file mode 100644 index 0000000..cceecbe --- /dev/null +++ b/formal/sonification/evidence/mat009-source-bind-001/receipt.json @@ -0,0 +1,29 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "formal/sonification/mat009/source/source_bind.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:51:31.900841+00:00", + "ended_utc": "2026-11-10T00:51:31.949116+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "CLEAN", + "inputs": { + "formal/sonification/mat009/source/source_bind.py": "575ab1ea12186419bc6dbae31e12ae1e45d46a3b3c4a630b63e0a53853433beb", + "formal/sonification/mat009/source/SOURCE_BINDING.json": "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "5a3750fcbab24ba5889a7a5439b5445d7484ac50a497ab546df22139462902b7", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/evidence/mat009-source-bind-001/stderr.log b/formal/sonification/evidence/mat009-source-bind-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-source-bind-001/stdout.log b/formal/sonification/evidence/mat009-source-bind-001/stdout.log new file mode 100644 index 0000000..631c1d9 --- /dev/null +++ b/formal/sonification/evidence/mat009-source-bind-001/stdout.log @@ -0,0 +1 @@ +{"assurance": "SOURCE_SYNTAX_PINNED_ONLY", "commit": "0758a96360726aafbb07abed34620eda178407ae", "direct_parent_sha256": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", "refinement_to_cpython": "OPEN", "selected_functions": 8, "status": "SOURCE_SYNTAX_MATCH", "tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", "target_sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", "tree": "a6a03e1227e666680d656b886201ee9dde9de32d"} diff --git a/formal/sonification/evidence/mat009-source-bind-001/tracked-diff.patch b/formal/sonification/evidence/mat009-source-bind-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-source-bind-001/worktree-status.txt b/formal/sonification/evidence/mat009-source-bind-001/worktree-status.txt new file mode 100644 index 0000000..e69de29 From f8665bc55a0577294575b73f305e76552a0bc468 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:24:35 +1030 Subject: [PATCH 03/22] formal(mat009): bind retained source and finite receipts --- formal/sonification/mat009/verify_evidence.py | 134 ++++++++++++++++++ ...est_sonification_formal_mat009_receipts.py | 54 +++++++ 2 files changed, 188 insertions(+) create mode 100644 formal/sonification/mat009/verify_evidence.py create mode 100644 tests/test_sonification_formal_mat009_receipts.py diff --git a/formal/sonification/mat009/verify_evidence.py b/formal/sonification/mat009/verify_evidence.py new file mode 100644 index 0000000..db834d3 --- /dev/null +++ b/formal/sonification/mat009/verify_evidence.py @@ -0,0 +1,134 @@ +"""Bind the retained MAT009 source and finite receipts to the source checkpoint. + +This checks archive integrity and local test inputs. It does not turn finite +execution into a proof of CPython semantics or authenticate physical evidence. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import subprocess +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[3] +EVIDENCE = ROOT / "formal/sonification/evidence" +SOURCE_CHECKPOINT = "38b5f9e99a5ce3f267c004362acf00ac0dc11342" +SOURCE_BINDING = "formal/sonification/mat009/source/SOURCE_BINDING.json" +SOURCE_BINDER = "formal/sonification/mat009/source/source_bind.py" +FINITE_TEST = "tests/test_sonification_formal_mat009_split.py" +FROZEN_TEST = "tests/test_mat_spec_009.py" + +# The SHA-256 values pin the reviewed receipt files, including their recorded +# commands, input hashes, original stream hashes, tool identities and status. +RECEIPTS = { + "mat009-source-bind-001": { + "sha256": "e3c3793f25532f540ba20b79729c5f20ede2398470ed2ffa8d75705cb93c5606", + "worktree_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "argv": ["python3", SOURCE_BINDER], + "inputs": {SOURCE_BINDER, SOURCE_BINDING}, + }, + "mat009-finite-001": { + "sha256": "b86b0b4ee2119ff0afffbd6ec575d9f2f3304fe6aaaa90cf3d6c43cae50f05e9", + "worktree_sha256": "36528314ce41776bf58b80e489e1b96af92c4a086b413864f5ba6904070acf25", + "argv": [ + "python3", "-m", "unittest", "discover", "-s", "tests", "-p", + "test_sonification_formal_mat009_split.py", "-q", + ], + "inputs": {SOURCE_BINDING, FINITE_TEST}, + }, + "mat009-ruff-source-001": { + "sha256": "efe30f79371ca762ac498a06e7e49c7b330b644d6b8bcb2cfbc37a7e60c0b4fd", + "worktree_sha256": "009b0dc9d39fc77af691d2724fde7be97ecf743dccd838871db42cdef903121e", + "argv": [ + "uv", "run", "--no-project", "--offline", "--with", "ruff", "ruff", + "check", SOURCE_BINDER, FINITE_TEST, + ], + "inputs": {SOURCE_BINDER, FINITE_TEST}, + }, + "mat009-pytest-001": { + "sha256": "cd00d1ebda66b847432194d9b53ffa22060bfa518c6c6b99dc9e63ea1fe0996f", + "worktree_sha256": "19b35e6445bc6c3fdde34ea5f92c17eda4e94231263247d37c28ba7f1d61459e", + "argv": ["python3", "-m", "pytest", "-q", FINITE_TEST, FROZEN_TEST], + "inputs": {SOURCE_BINDING, FINITE_TEST, FROZEN_TEST}, + }, +} + + +def sha(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def verify(evidence: Path = EVIDENCE) -> dict: + """Reject missing, changed, failed or input-stale mandatory receipts.""" + for name, expected in RECEIPTS.items(): + directory = evidence / name + if directory.is_symlink() or not directory.is_dir(): + raise ValueError(f"missing ordinary receipt directory: {name}") + required = { + "receipt.json", "stdout.log", "stderr.log", "worktree-status.txt", + "tracked-diff.patch", + } + if {p.name for p in directory.iterdir()} != required: + raise ValueError(f"receipt file inventory changed: {name}") + for member in required: + if (directory / member).is_symlink() or not (directory / member).is_file(): + raise ValueError(f"missing ordinary receipt file: {name}/{member}") + raw = (directory / "receipt.json").read_bytes() + if sha(raw) != expected["sha256"]: + raise ValueError(f"receipt changed: {name}") + receipt = json.loads(raw) + if ( + receipt.get("schema") != "qsol.sonification-formal-001.execution/v1" + or receipt.get("checkout_commit") != SOURCE_CHECKPOINT + or receipt.get("argv") != expected["argv"] + or receipt.get("exit_code") != 0 + or set(receipt.get("inputs", {})) != expected["inputs"] + ): + raise ValueError(f"execution identity or outcome changed: {name}") + for stream in ("stdout", "stderr"): + if sha((directory / f"{stream}.log").read_bytes()) != receipt[f"{stream}_sha256"]: + raise ValueError(f"recorded {stream} changed: {name}") + if sha((directory / "worktree-status.txt").read_bytes()) != expected["worktree_sha256"]: + raise ValueError(f"recorded worktree status changed: {name}") + if (directory / "tracked-diff.patch").read_bytes(): + raise ValueError(f"recorded tracked input diff is nonempty: {name}") + for relative, digest in receipt["inputs"].items(): + current = ROOT / relative + if current.is_symlink() or not current.is_file() or sha(current.read_bytes()) != digest: + raise ValueError(f"current test input changed: {relative}") + historical = subprocess.check_output( + ["git", "show", f"{SOURCE_CHECKPOINT}:{relative}"], cwd=ROOT + ) + if sha(historical) != digest: + raise ValueError(f"checkpoint test input changed: {relative}") + + binding_output = (evidence / "mat009-source-bind-001/stdout.log").read_text() + binding = json.loads(binding_output) + if ( + binding.get("status") != "SOURCE_SYNTAX_MATCH" + or binding.get("refinement_to_cpython") != "OPEN" + or binding.get("commit") != "0758a96360726aafbb07abed34620eda178407ae" + or binding.get("target_sha256") + != "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690" + ): + raise ValueError("frozen source binder output changed") + if "Ran 18 tests" not in (evidence / "mat009-finite-001/stderr.log").read_text(): + raise ValueError("finite test summary missing") + if "35 passed, 36 subtests passed" not in ( + evidence / "mat009-pytest-001/stdout.log" + ).read_text(): + raise ValueError("targeted pytest summary missing") + return { + "status": "MAT009_SOURCE_FINITE_RECEIPTS_BOUND", + "receipt_count": len(RECEIPTS), + "REFINEMENT_PROVED": "OPEN", + } + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--evidence", type=Path, default=EVIDENCE) + args = parser.parse_args() + print(json.dumps(verify(args.evidence), sort_keys=True)) diff --git a/tests/test_sonification_formal_mat009_receipts.py b/tests/test_sonification_formal_mat009_receipts.py new file mode 100644 index 0000000..a704a94 --- /dev/null +++ b/tests/test_sonification_formal_mat009_receipts.py @@ -0,0 +1,54 @@ +"""Fail-closed controls for retained MAT009 source and finite receipts.""" + +from __future__ import annotations + +import shutil +import tempfile +import unittest +from pathlib import Path + +from formal.sonification.mat009.verify_evidence import EVIDENCE, RECEIPTS, verify + + +class Mat009ReceiptTests(unittest.TestCase): + def setUp(self) -> None: + self.temp = tempfile.TemporaryDirectory(prefix="mat009-receipt-control-") + self.addCleanup(self.temp.cleanup) + self.evidence = Path(self.temp.name) + for name in RECEIPTS: + shutil.copytree(EVIDENCE / name, self.evidence / name) + + def test_intact_receipts(self) -> None: + result = verify(self.evidence) + self.assertEqual(result["status"], "MAT009_SOURCE_FINITE_RECEIPTS_BOUND") + self.assertEqual(result["REFINEMENT_PROVED"], "OPEN") + + def test_missing_mandatory_receipt(self) -> None: + shutil.rmtree(self.evidence / "mat009-finite-001") + with self.assertRaisesRegex(ValueError, "missing ordinary receipt directory"): + verify(self.evidence) + + def test_missing_recorded_stream(self) -> None: + (self.evidence / "mat009-finite-001/stderr.log").unlink() + with self.assertRaisesRegex(ValueError, "receipt file inventory changed"): + verify(self.evidence) + + def test_altered_recorded_stream(self) -> None: + (self.evidence / "mat009-finite-001/stderr.log").write_text("Ran 18 tests; OK\n") + with self.assertRaisesRegex(ValueError, "recorded stderr changed"): + verify(self.evidence) + + def test_altered_receipt_claim(self) -> None: + receipt = self.evidence / "mat009-source-bind-001/receipt.json" + receipt.write_text(receipt.read_text().replace('"exit_code": 0', '"exit_code": 1')) + with self.assertRaisesRegex(ValueError, "receipt changed"): + verify(self.evidence) + + def test_altered_worktree_status(self) -> None: + (self.evidence / "mat009-pytest-001/worktree-status.txt").write_text("clean\n") + with self.assertRaisesRegex(ValueError, "recorded worktree status changed"): + verify(self.evidence) + + +if __name__ == "__main__": + unittest.main() From ac8265dc3b693e6900c7343ec1ea7dcd643b3d31 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:27:56 +1030 Subject: [PATCH 04/22] formal(mat009): prove scoped split and first-owner models in Lean --- .../mat009/lean/DiagnosticFirstOwner.lean | 78 ++++ .../sonification/mat009/lean/ExactTypes.lean | 98 +++++ .../sonification/mat009/lean/LeanAudit.lean | 66 +++ .../sonification/mat009/lean/PROOF_NOTES.md | 41 ++ .../sonification/mat009/lean/SplitModel.lean | 379 ++++++++++++++++++ .../mat009/lean/TypedConsumer.lean | 65 +++ 6 files changed, 727 insertions(+) create mode 100644 formal/sonification/mat009/lean/DiagnosticFirstOwner.lean create mode 100644 formal/sonification/mat009/lean/ExactTypes.lean create mode 100644 formal/sonification/mat009/lean/LeanAudit.lean create mode 100644 formal/sonification/mat009/lean/PROOF_NOTES.md create mode 100644 formal/sonification/mat009/lean/SplitModel.lean create mode 100644 formal/sonification/mat009/lean/TypedConsumer.lean diff --git a/formal/sonification/mat009/lean/DiagnosticFirstOwner.lean b/formal/sonification/mat009/lean/DiagnosticFirstOwner.lean new file mode 100644 index 0000000..7283ce6 --- /dev/null +++ b/formal/sonification/mat009/lean/DiagnosticFirstOwner.lean @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some first + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/lean/ExactTypes.lean b/formal/sonification/mat009/lean/ExactTypes.lean new file mode 100644 index 0000000..7e5be3e --- /dev/null +++ b/formal/sonification/mat009/lean/ExactTypes.lean @@ -0,0 +1,98 @@ +import TypedConsumer + +/-! +Independent typed uses of the intended MAT009 model propositions. A theorem +with the same name but a weaker type, such as `True`, cannot satisfy these +consumers. These are statements about eligible-row mathematical models only. +-/ + +namespace MAT009.ExactTypes +open MAT009 + +example (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := + M009_R1_initial parent role campaign lab reason + +example (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := + M009_R2_assignment_overwrite s row + +example (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := + M009_R3_cross_role_trigger s row + +example (s : State) (row : Row) (role : Role) + (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := + M009_R4_stickiness s row role campaign lab reason + +example (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := + M009_R5_final_set_intersection s + +example (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := + M009_R5_parent_union s + +example (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := + M009_R6_arbitrary_finite_scan parent rows role campaign lab reason + +example (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign := + M009_R6_latest_owner parent rows campaign + +example (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := + M009_R6_final_leakage_iff parent rows + +example : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := + M009_R7_nonvacuous + +example (registry : MAT009.Diagnostic.Registry) + (updates : List (String × MAT009.Diagnostic.Owner)) + (key : String) (first : MAT009.Diagnostic.Owner) + (h : registry key = some first) : + (MAT009.Diagnostic.scan registry updates) key = some first := + MAT009.Diagnostic.scan_first_owner_sticky registry updates key first h + +end MAT009.ExactTypes diff --git a/formal/sonification/mat009/lean/LeanAudit.lean b/formal/sonification/mat009/lean/LeanAudit.lean new file mode 100644 index 0000000..897b509 --- /dev/null +++ b/formal/sonification/mat009/lean/LeanAudit.lean @@ -0,0 +1,66 @@ +import ExactTypes +import Lean + +/-! +Enumerate every declaration whose origin is a MAT009 proof module, including +helpers and typed consumers. The script that runs this module checks the +inventory. `collectAxioms` traverses each declaration's logical dependencies. +-/ + +open Lean Elab Command + +run_cmd do + let env ← getEnv + let origins := #[ + `SplitModel, `DiagnosticFirstOwner, `TypedConsumer, `ExactTypes, + env.mainModule + ] + for mod in origins do + unless mod == env.mainModule || (env.getModuleIdx? mod).isSome do + throwError "missing required imported module {mod}" + logInfo m!"MAT009_MODULE {mod}" + for mod in env.header.moduleNames do + logInfo m!"MAT009_IMPORT {mod}" + let allowed := #[`propext, `Quot.sound, `Classical.choice] + let mut seen : Nat := 0 + let mut theorems : Nat := 0 + let declarations := env.checked.get.constants.toList.mergeSort fun a b => + decide (a.1.toString ≤ b.1.toString) + for (name, info) in declarations do + let origin := match env.getModuleIdxFor? name with + | some idx => env.header.moduleNames[idx.toNat]! + | none => env.mainModule + if origins.contains origin then + seen := seen + 1 + if info matches .thmInfo _ then + theorems := theorems + 1 + let generated := name.toString.endsWith "_cstage1" || + name.toString.endsWith "_cstage2" || + (name.toString.splitOn "._closed_").length > 1 || + (name.toString.splitOn "._elambda_").length > 1 + if info matches .axiomInfo _ then + unless generated do + throwError "project axiom declaration {name}" + let axioms ← collectAxioms name + let unsafeDef : Bool := match info with + | .defnInfo d => d.safety == DefinitionSafety.unsafe + | _ => false + for ax in axioms do + unless allowed.contains ax || generated do + throwError "unapproved transitive axiom {ax} in {name} (origin {origin})" + if unsafeDef && !generated then + throwError "unsafe project definition {name}" + let row := Json.mkObj [ + ("origin", toJson origin.toString), + ("declaration", toJson name.toString), + ("kind", toJson (if generated then "compiler_auxiliary" else + if info matches .thmInfo _ then "theorem" else "non_theorem")), + ("is_axiom", toJson (info matches .axiomInfo _)), + ("unsafe_definition", toJson unsafeDef), + ("type", toJson (← liftTermElabM do + pure (← Lean.Meta.ppExpr info.type).pretty)), + ("axioms", toJson (axioms.map Name.toString))] + logInfo m!"MAT009_DECL {row.compress}" + if seen == 0 || theorems == 0 then + throwError "empty proof inventory" + logInfo m!"MAT009_AUDIT declarations={seen} theorems={theorems}" diff --git a/formal/sonification/mat009/lean/PROOF_NOTES.md b/formal/sonification/mat009/lean/PROOF_NOTES.md new file mode 100644 index 0000000..603204a --- /dev/null +++ b/formal/sonification/mat009/lean/PROOF_NOTES.md @@ -0,0 +1,41 @@ +# MAT009 split-model proof notes + +`SplitModel.lean` models only rows that have passed the child campaign, role, +and lab guards. Parent reason IDs are an arbitrary input set. `step` updates +the latest campaign owner and persistent membership sets. `finalize` performs +the campaign/lab set intersection after the full scan. `DiagnosticFirstOwner.lean` +separately models one validated diagnostic identity registry's `setdefault` +behavior. These are mathematical models, not a refinement proof for the frozen +Python source or CPython execution. + +## Failed attempts retained + +- The first direct `lean SplitModel.lean` pass left goals in R2 (a nonmatching + key needed an introduced `key ≠ row.campaign` hypothesis), R4 (set/reason + stickiness needed explicit `Or.inl`), and the scan membership proofs (the + existential over `row :: rest` needed an explicit head/tail equivalence). + All were discharged in the compiled file. +- `prefix` was rejected as a Lean keyword in the finite-scan theorem. The + binders are now `before` and `after`. +- The first diagnostic registry compile left the `key = identity` branch + unresolved in `register_preserves_existing`. Substituting the key before + simplification discharged it. + +## Counterexamples preserved in Lean + +- `overwrite_retains_both_split_memberships`: after TRAIN then HOLDOUT for the + same campaign, its latest owner is HOLDOUT while both historical campaign + memberships remain. A final-owner-only leakage test would miss this case. +- `parent_can_supply_leakage_reason`: a parent can supply the leakage reason + ID while the child has no campaign/lab intersection. The final union and + child intersection are distinct predicates. +- `Diagnostic.first_owner_not_last_writer`: a later different diagnostic + claimant does not overwrite the first owner. + +## Open boundary + +The child eligibility guards, other child checks (phases, receipts, units, +pressure, scale, labels, diagnostic validity), MAT008's implementation, +source-to-model correspondence, and CPython refinement are outside these +theorems. `STRUCTURAL_ONLY_UNAUTHENTICATED` is represented only as a status; +no physical evidence or independence is authenticated. diff --git a/formal/sonification/mat009/lean/SplitModel.lean b/formal/sonification/mat009/lean/SplitModel.lean new file mode 100644 index 0000000..dc3eaf6 --- /dev/null +++ b/formal/sonification/mat009/lean/SplitModel.lean @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/lean/TypedConsumer.lean b/formal/sonification/mat009/lean/TypedConsumer.lean new file mode 100644 index 0000000..2158aca --- /dev/null +++ b/formal/sonification/mat009/lean/TypedConsumer.lean @@ -0,0 +1,65 @@ +import SplitModel +import DiagnosticFirstOwner + +/-! +A separate import consumer for the MAT009 split model. These declarations +type-check the public R1–R7 interface and derive blocked outcomes from the +generic finite-scan and parent-reason theorems. +-/ + +namespace MAT009.Consumer + +#check M009_R1_initial +#check M009_R2_assignment_overwrite +#check M009_R3_cross_role_trigger +#check M009_R4_stickiness +#check M009_R5_final_set_intersection +#check M009_R5_parent_union +#check M009_R6_cross_trigger_in_finite_scan +#check M009_R6_arbitrary_finite_scan +#check M009_R6_latest_owner +#check M009_R6_parent_reason_survives +#check M009_R6_final_leakage_iff +#check M009_R7_accepted_example +#check M009_R7_rejected_example +#check M009_R7_nonvacuous +#check MAT009.Diagnostic.scan_first_owner_sticky + +theorem parent_reason_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (reason : String) (h : parent reason) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + exact ⟨reason, M009_R6_parent_reason_survives parent rows reason h⟩ + +theorem shared_campaign_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (campaign : String) + (htrain : ∃ row ∈ rows, + row.role = .train ∧ row.campaign = campaign) + (hholdout : ∃ row ∈ rows, + row.role = .holdout ∧ row.campaign = campaign) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + refine ⟨leakageReason, Or.inr ?_⟩ + exact (M009_R6_final_leakage_iff parent rows).2 + (Or.inl ⟨campaign, htrain, hholdout⟩) + +#print axioms M009_R1_initial +#print axioms M009_R2_assignment_overwrite +#print axioms M009_R3_cross_role_trigger +#print axioms M009_R4_stickiness +#print axioms M009_R5_final_set_intersection +#print axioms M009_R5_parent_union +#print axioms M009_R6_cross_trigger_in_finite_scan +#print axioms M009_R6_arbitrary_finite_scan +#print axioms M009_R6_latest_owner +#print axioms M009_R6_parent_reason_survives +#print axioms M009_R6_final_leakage_iff +#print axioms M009_R7_accepted_example +#print axioms M009_R7_rejected_example +#print axioms M009_R7_nonvacuous +#print axioms parent_reason_blocks_any_scan +#print axioms shared_campaign_blocks_any_scan +#print axioms MAT009.Diagnostic.scan_first_owner_sticky +#print axioms MAT009.Diagnostic.first_owner_not_last_writer + +end MAT009.Consumer From bc5c6cb73a00df0bf9189075b776c4a5a78888bf Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:29:04 +1030 Subject: [PATCH 05/22] formal(mat009): add fail-closed Lean model build and trust audit --- formal/sonification/mat009/lean/check.py | 274 ++++++++++++++++++ .../sonification/mat009/lean/lean-toolchain | 1 + 2 files changed, 275 insertions(+) create mode 100644 formal/sonification/mat009/lean/check.py create mode 100644 formal/sonification/mat009/lean/lean-toolchain diff --git a/formal/sonification/mat009/lean/check.py b/formal/sonification/mat009/lean/check.py new file mode 100644 index 0000000..4c61b3c --- /dev/null +++ b/formal/sonification/mat009/lean/check.py @@ -0,0 +1,274 @@ +#!/usr/bin/env python3 +"""Fresh-build and audit the source-pinned MAT009 mathematical modules. + +The receipt is about Lean model statements. It does not prove CPython source +refinement, physical source independence, or empirical classifier accuracy. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import os +import re +import subprocess +import sys +import tempfile +from datetime import UTC, datetime +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] +MODULES = ( + "SplitModel", "DiagnosticFirstOwner", "TypedConsumer", "ExactTypes", + "LeanAudit", +) +INPUTS = (*(f"{module}.lean" for module in MODULES), + "PROOF_NOTES.md", "lean-toolchain", "check.py", +) +NAMED_THEOREMS = { + *(f"MAT009.{name}" for name in ( + "M009_R1_initial", "M009_R2_assignment_overwrite", + "M009_R3_cross_role_trigger", "M009_R4_stickiness", + "M009_R5_final_set_intersection", "M009_R5_parent_union", + "M009_R6_cross_trigger_in_finite_scan", + "M009_R6_arbitrary_finite_scan", "M009_R6_latest_owner", + "M009_R6_parent_reason_survives", "M009_R6_final_leakage_iff", + "M009_R7_accepted_example", "M009_R7_rejected_example", + "M009_R7_nonvacuous", + )), + "MAT009.Consumer.parent_reason_blocks_any_scan", + "MAT009.Consumer.shared_campaign_blocks_any_scan", + "MAT009.Diagnostic.register_first_owner", + "MAT009.Diagnostic.register_new_owner", + "MAT009.Diagnostic.register_other_identity", + "MAT009.Diagnostic.register_preserves_existing", + "MAT009.Diagnostic.scan_first_owner_sticky", + "MAT009.Diagnostic.first_owner_not_last_writer", +} +PRINTED_AXIOMS = { + *(f"MAT009.{name}" for name in ( + "M009_R1_initial", "M009_R2_assignment_overwrite", + "M009_R3_cross_role_trigger", "M009_R4_stickiness", + "M009_R5_final_set_intersection", "M009_R5_parent_union", + "M009_R6_cross_trigger_in_finite_scan", + "M009_R6_arbitrary_finite_scan", "M009_R6_latest_owner", + "M009_R6_parent_reason_survives", "M009_R6_final_leakage_iff", + "M009_R7_accepted_example", "M009_R7_rejected_example", + "M009_R7_nonvacuous", + )), + "MAT009.Consumer.parent_reason_blocks_any_scan", + "MAT009.Consumer.shared_campaign_blocks_any_scan", + "MAT009.Diagnostic.scan_first_owner_sticky", + "MAT009.Diagnostic.first_owner_not_last_writer", +} +ALLOWED_LOGICAL_AXIOMS = {"propext", "Quot.sound", "Classical.choice"} +VERSION = "Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release)" +PROHIBITED = re.compile(r"\b(?:sorry|admit|axiom|opaque|unsafe|partial)\b") +AXIOM_LINE = re.compile( + r"^'([^']+)' (?:depends on axioms: \[([^]]*)\]|does not depend on any axioms)$" +) + + +def sha(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def record_command( + out: Path, label: str, argv: list[str], *, cwd: Path, env: dict[str, str], + timeout: int = 180, +) -> tuple[int | None, bytes, bytes, bool]: + timed_out = False + try: + run = subprocess.run(argv, cwd=cwd, env=env, capture_output=True, timeout=timeout) + code, stdout, stderr = run.returncode, run.stdout, run.stderr + except subprocess.TimeoutExpired as exc: + timed_out = True + code, stdout, stderr = None, exc.stdout or b"", exc.stderr or b"" + (out / f"{label}.stdout").write_bytes(stdout) + (out / f"{label}.stderr").write_bytes(stderr) + (out / f"{label}.json").write_text(json.dumps({ + "argv": argv, + "cwd": str(cwd), + "exit_code": code, + "timed_out": timed_out, + "timeout_seconds": timeout, + "stdout_sha256": sha(stdout), + "stderr_sha256": sha(stderr), + }, indent=2, sort_keys=True) + "\n") + return code, stdout, stderr, timed_out + + +def verify_baseline(commit: str) -> dict[str, str]: + if not re.fullmatch(r"[0-9a-f]{40}", commit): + raise ValueError("proof baseline must be a full Git commit SHA") + subprocess.run( + ["git", "merge-base", "--is-ancestor", commit, "HEAD"], + cwd=ROOT, check=True, capture_output=True, + ) + observed = {} + for name in INPUTS: + current = HERE / name + if current.is_symlink() or not current.is_file(): + raise ValueError(f"missing ordinary proof input: {name}") + raw = current.read_bytes() + historical = subprocess.check_output( + ["git", "show", f"{commit}:formal/sonification/mat009/lean/{name}"], + cwd=ROOT, + ) + if raw != historical: + raise ValueError(f"stale proof input: {name}") + observed[name] = sha(raw) + actual_modules = { + str(p.relative_to(HERE)) for p in HERE.rglob("*.lean") + if ".lake" not in p.parts + } + if actual_modules != {f"{module}.lean" for module in MODULES}: + raise ValueError(f"Lean source module coverage changed: {sorted(actual_modules)}") + for module in MODULES[:-1]: + if PROHIBITED.search((HERE / f"{module}.lean").read_text()): + raise ValueError(f"prohibited proof shortcut in {module}") + if (HERE / "lean-toolchain").read_text() != "leanprover/lean4:v4.19.0\n": + raise ValueError("Lean toolchain declaration changed") + return observed + + +def audit_output(raw: bytes, lean: Path, out: Path) -> dict: + lines = raw.decode("utf-8").splitlines() + modules = {line.removeprefix("MAT009_MODULE ") for line in lines + if line.startswith("MAT009_MODULE ")} + if modules != set(MODULES): + raise ValueError(f"imported proof module coverage mismatch: {sorted(modules)}") + summary = [line for line in lines if line.startswith("MAT009_AUDIT ")] + if summary != ["MAT009_AUDIT declarations=351 theorems=95"]: + raise ValueError("complete declaration/theorem inventory changed") + declarations = [json.loads(line.removeprefix("MAT009_DECL ")) for line in lines + if line.startswith("MAT009_DECL ")] + names = [row["declaration"] for row in declarations] + if len(names) != 351 or len(set(names)) != 351: + raise ValueError("duplicate or missing proof declaration") + if sum(row["kind"] == "theorem" for row in declarations) != 95: + raise ValueError("theorem declaration inventory changed") + named = {row["declaration"] for row in declarations + if row["kind"] == "theorem" and row["declaration"] in NAMED_THEOREMS} + if named != NAMED_THEOREMS: + raise ValueError(f"named intended theorem missing: {sorted(NAMED_THEOREMS - named)}") + for row in declarations: + if row["origin"] not in MODULES: + raise ValueError(f"unexpected proof declaration origin: {row['origin']}") + if row["kind"] != "compiler_auxiliary": + if row["is_axiom"] or row["unsafe_definition"]: + raise ValueError(f"logical declaration contains trusted code: {row['declaration']}") + if not set(row["axioms"]) <= ALLOWED_LOGICAL_AXIOMS: + raise ValueError(f"unapproved logical axiom: {row['declaration']}") + (out / "declarations.json").write_text( + json.dumps(declarations, indent=2, sort_keys=True) + "\n" + ) + imports = {line.removeprefix("MAT009_IMPORT ") for line in lines + if line.startswith("MAT009_IMPORT ")} + if not {"SplitModel", "DiagnosticFirstOwner", "TypedConsumer", "ExactTypes"} <= imports: + raise ValueError("project import dependency missing") + toolchain_root = lean.parent.parent + external = {} + for module in sorted(imports - set(MODULES)): + relative = Path("lib/lean") / (module.replace(".", "/") + ".olean") + path = toolchain_root / relative + if path.is_symlink() or not path.is_file(): + raise ValueError(f"missing toolchain import: {relative}") + external[module] = {"relative_path": str(relative), "sha256": sha(path.read_bytes())} + (out / "toolchain-imports.json").write_text( + json.dumps(external, indent=2, sort_keys=True) + "\n" + ) + types = {row["declaration"]: row["type"] for row in declarations + if row["declaration"] in NAMED_THEOREMS} + (out / "theorem-types.json").write_text( + json.dumps(types, indent=2, sort_keys=True) + "\n" + ) + return { + "declaration_count": len(declarations), + "theorem_declaration_count_including_generated": 95, + "named_intended_theorems": sorted(named), + "external_import_count": len(external), + "logical_axioms": sorted(ALLOWED_LOGICAL_AXIOMS), + "compiler_auxiliary_count": sum(row["kind"] == "compiler_auxiliary" + for row in declarations), + } + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--lean", required=True, type=Path) + parser.add_argument("--baseline-commit", required=True) + parser.add_argument("--out", required=True, type=Path) + args = parser.parse_args() + out = args.out.resolve() + out.mkdir(parents=True, exist_ok=False) + report = { + "status": "INCOMPLETE", + "baseline_commit": args.baseline_commit, + "started_utc": datetime.now(UTC).isoformat(), + "MODEL_PROVED": "NOT_EXECUTED", + "REFINEMENT_PROVED": "OPEN", + "DIFFERENTIAL_TESTED": "NOT_EXECUTED", + "AUDIT_ACCEPTED": "OPEN", + } + try: + report["input_sha256"] = verify_baseline(args.baseline_commit) + lean = args.lean.resolve(strict=True) + report["lean_executable_sha256"] = sha(lean.read_bytes()) + code, stdout, _, timeout = record_command( + out, "lean-version", [str(lean), "--version"], cwd=ROOT, + env=os.environ.copy(), timeout=30, + ) + if timeout or code != 0 or stdout.decode().strip() != VERSION: + raise ValueError("pinned Lean version mismatch") + report["lean_version"] = VERSION + with tempfile.TemporaryDirectory(prefix="mat009-lean-build-") as temp: + build = Path(temp) + env = {**os.environ, "LEAN_PATH": str(build)} + for number, module in enumerate(MODULES): + argv = [ + str(lean), "--error=warning", "-o", + str(build / f"{module}.olean"), str(HERE / f"{module}.lean"), + ] + code, stdout, _, timeout = record_command( + out, f"build-{number:02d}-{module}", argv, cwd=ROOT, env=env + ) + if timeout or code != 0: + raise ValueError(f"Lean rejected or timed out on {module}") + if module == "TypedConsumer": + found = {} + for line in stdout.decode().splitlines(): + match = AXIOM_LINE.match(line) + if match: + found[match[1]] = ( + set(a.strip() for a in match[2].split(",")) + if match[2] else set() + ) + if set(found) != PRINTED_AXIOMS: + raise ValueError("typed consumer axiom report coverage changed") + if any(not value <= ALLOWED_LOGICAL_AXIOMS for value in found.values()): + raise ValueError("typed consumer depends on unapproved axioms") + (out / "named-axioms.json").write_text( + json.dumps({key: sorted(value) for key, value in found.items()}, + indent=2, sort_keys=True) + "\n" + ) + if module == "LeanAudit": + report.update(audit_output(stdout, lean, out)) + report["status"] = "PASS" + report["MODEL_PROVED"] = "PASS_FOR_SCOPED_MATHEMATICAL_MODEL" + except (OSError, ValueError, subprocess.SubprocessError, UnicodeError) as exc: + report["status"] = "FAIL" + report["error"] = str(exc) + report["completed_utc"] = datetime.now(UTC).isoformat() + (out / "result.json").write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + print(json.dumps({ + "status": report["status"], "out": str(out), "error": report.get("error"), + "named_theorems": len(report.get("named_intended_theorems", [])), + }, sort_keys=True)) + return 0 if report["status"] == "PASS" else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/formal/sonification/mat009/lean/lean-toolchain b/formal/sonification/mat009/lean/lean-toolchain new file mode 100644 index 0000000..7aca1d8 --- /dev/null +++ b/formal/sonification/mat009/lean/lean-toolchain @@ -0,0 +1 @@ +leanprover/lean4:v4.19.0 From a09aab6572fb9c3875d5f2940bdb17ec55c358d5 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:29:50 +1030 Subject: [PATCH 06/22] formal(mat009): retain failed audit-module locator attempt and fix runner --- .../sonification/mat009/lean/PROOF_NOTES.md | 7 + .../attempts/001/build-00-SplitModel.json | 15 + .../attempts/001/build-00-SplitModel.stderr | 0 .../attempts/001/build-00-SplitModel.stdout | 0 .../001/build-01-DiagnosticFirstOwner.json | 15 + .../001/build-01-DiagnosticFirstOwner.stderr | 0 .../001/build-01-DiagnosticFirstOwner.stdout | 0 .../attempts/001/build-02-TypedConsumer.json | 15 + .../001/build-02-TypedConsumer.stderr | 0 .../001/build-02-TypedConsumer.stdout | 71 + .../attempts/001/build-03-ExactTypes.json | 15 + .../attempts/001/build-03-ExactTypes.stderr | 0 .../attempts/001/build-03-ExactTypes.stdout | 0 .../lean/attempts/001/build-04-LeanAudit.json | 15 + .../attempts/001/build-04-LeanAudit.stderr | 0 .../attempts/001/build-04-LeanAudit.stdout | 1664 +++++++++++++++++ .../lean/attempts/001/lean-version.json | 12 + .../lean/attempts/001/lean-version.stderr | 0 .../lean/attempts/001/lean-version.stdout | 1 + .../lean/attempts/001/named-axioms.json | 62 + .../mat009/lean/attempts/001/result.json | 23 + formal/sonification/mat009/lean/check.py | 4 +- 22 files changed, 1917 insertions(+), 2 deletions(-) create mode 100644 formal/sonification/mat009/lean/attempts/001/build-00-SplitModel.json create mode 100644 formal/sonification/mat009/lean/attempts/001/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/attempts/001/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/attempts/001/build-01-DiagnosticFirstOwner.json create mode 100644 formal/sonification/mat009/lean/attempts/001/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/attempts/001/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/attempts/001/build-02-TypedConsumer.json create mode 100644 formal/sonification/mat009/lean/attempts/001/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/attempts/001/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/attempts/001/build-03-ExactTypes.json create mode 100644 formal/sonification/mat009/lean/attempts/001/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/lean/attempts/001/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/lean/attempts/001/build-04-LeanAudit.json create mode 100644 formal/sonification/mat009/lean/attempts/001/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/lean/attempts/001/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/lean/attempts/001/lean-version.json create mode 100644 formal/sonification/mat009/lean/attempts/001/lean-version.stderr create mode 100644 formal/sonification/mat009/lean/attempts/001/lean-version.stdout create mode 100644 formal/sonification/mat009/lean/attempts/001/named-axioms.json create mode 100644 formal/sonification/mat009/lean/attempts/001/result.json diff --git a/formal/sonification/mat009/lean/PROOF_NOTES.md b/formal/sonification/mat009/lean/PROOF_NOTES.md index 603204a..747d5b9 100644 --- a/formal/sonification/mat009/lean/PROOF_NOTES.md +++ b/formal/sonification/mat009/lean/PROOF_NOTES.md @@ -10,6 +10,13 @@ Python source or CPython execution. ## Failed attempts retained +- `attempts/001/` retains the first full checker execution against proof-input + commit `bc5c6cb73a00df0bf9189075b776c4a5a78888bf`. Every Lean module + compiled, but the checker rejected its own audit-module identity because it + invoked that file by an absolute path. The resulting main-module name was + `formal.sonification.mat009.lean.LeanAudit` rather than `LeanAudit`. This was + a receipt-binding defect, not a mathematical proof failure. The subsequent + checker invokes modules from their proof directory by basename. - The first direct `lean SplitModel.lean` pass left goals in R2 (a nonmatching key needed an introduced `key ≠ row.campaign` hypothesis), R4 (set/reason stickiness needed explicit `Or.inl`), and the scan membership proofs (the diff --git a/formal/sonification/mat009/lean/attempts/001/build-00-SplitModel.json b/formal/sonification/mat009/lean/attempts/001/build-00-SplitModel.json new file mode 100644 index 0000000..fa3f7cb --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/001/build-00-SplitModel.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-91v74_op/SplitModel.olean", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/001/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/attempts/001/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/001/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/attempts/001/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/001/build-01-DiagnosticFirstOwner.json b/formal/sonification/mat009/lean/attempts/001/build-01-DiagnosticFirstOwner.json new file mode 100644 index 0000000..577ccd5 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/001/build-01-DiagnosticFirstOwner.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-91v74_op/DiagnosticFirstOwner.olean", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/001/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/attempts/001/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/001/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/attempts/001/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/001/build-02-TypedConsumer.json b/formal/sonification/mat009/lean/attempts/001/build-02-TypedConsumer.json new file mode 100644 index 0000000..35aaa07 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/001/build-02-TypedConsumer.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-91v74_op/TypedConsumer.olean", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/001/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/attempts/001/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/001/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/attempts/001/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/001/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/attempts/001/build-03-ExactTypes.json b/formal/sonification/mat009/lean/attempts/001/build-03-ExactTypes.json new file mode 100644 index 0000000..28cce35 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/001/build-03-ExactTypes.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-91v74_op/ExactTypes.olean", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/001/build-03-ExactTypes.stderr b/formal/sonification/mat009/lean/attempts/001/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/001/build-03-ExactTypes.stdout b/formal/sonification/mat009/lean/attempts/001/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/001/build-04-LeanAudit.json b/formal/sonification/mat009/lean/attempts/001/build-04-LeanAudit.json new file mode 100644 index 0000000..fdf6a8a --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/001/build-04-LeanAudit.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-91v74_op/LeanAudit.olean", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9f2de47436cb49685c109879a16bda1cfe13367025eae0160e0e489c990e9f4f", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/001/build-04-LeanAudit.stderr b/formal/sonification/mat009/lean/attempts/001/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/001/build-04-LeanAudit.stdout b/formal/sonification/mat009/lean/attempts/001/build-04-LeanAudit.stdout new file mode 100644 index 0000000..81c8275 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/001/build-04-LeanAudit.stdout @@ -0,0 +1,1664 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE formal.sonification.mat009.lean.LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.initial","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._closed_1._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.initial._elambda_1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.initial.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_3","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_4","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRow","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._closed_1._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.lastRole [] x = none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_2._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.leakageReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.leakageReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.noParent","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.noParent x = False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.noParent.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout ∧\n s.campaigns MAT009.Role.train \"SAME\" ∧ s.campaigns MAT009.Role.holdout \"SAME\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.overwrite_retains_both_split_memberships","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason ∧ ¬(MAT009.finalize s).childReason MAT009.leakageReason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_can_supply_leakage_reason","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (reason : String), s.parent reason → (MAT009.finalize s).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_reason_survives_finalization","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.scan s [] = s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_append","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key ↔\n s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), s.crossed → (MAT009.scan s rows).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_crossed_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.scan s rows)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_familyLeakage_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key ↔ s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_owner_last","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason ↔ s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.Role → String → Prop) → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.splitIntersection","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (members : MAT009.Role → String → Prop),\n MAT009.splitIntersection members = ∃ key, members MAT009.Role.train key ∧ members MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.splitIntersection.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.step","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.step._elambda_1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key ∨ role = row.role ∧ key = row.campaign,\n labs := fun role key => s.labs role key ∨ role = row.role ∧ key = row.lab,\n crossed := s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role,\n parent := s.parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.step.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String × MAT009.Diagnostic.Owner)) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (x : String) (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.lastRole.match_2.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.lastRole.match_2.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.lastRole.match_2.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole._@.formal.sonification.mat009.lean.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.match_1._@.formal.sonification.mat009.lean.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.match_1.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRole.«_@».formal.sonification.mat009.lean.SplitModel._hyg.109._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow._@.formal.sonification.mat009.lean.SplitModel._hyg.221","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_15._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_16._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_17._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_18._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_19._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_20._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_21._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprRow.«_@».formal.sonification.mat009.lean.SplitModel._hyg.221._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus._@.formal.sonification.mat009.lean.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.match_1._@.formal.sonification.mat009.lean.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.match_1.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.reprStatus.«_@».formal.sonification.mat009.lean.SplitModel._hyg.882._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.formal.sonification.mat009.lean.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_AUDIT declarations=351 theorems=95 diff --git a/formal/sonification/mat009/lean/attempts/001/lean-version.json b/formal/sonification/mat009/lean/attempts/001/lean-version.json new file mode 100644 index 0000000..10f4b46 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/001/lean-version.json @@ -0,0 +1,12 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--version" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b", + "timed_out": false, + "timeout_seconds": 30 +} diff --git a/formal/sonification/mat009/lean/attempts/001/lean-version.stderr b/formal/sonification/mat009/lean/attempts/001/lean-version.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/001/lean-version.stdout b/formal/sonification/mat009/lean/attempts/001/lean-version.stdout new file mode 100644 index 0000000..507e58d --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/001/lean-version.stdout @@ -0,0 +1 @@ +Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release) diff --git a/formal/sonification/mat009/lean/attempts/001/named-axioms.json b/formal/sonification/mat009/lean/attempts/001/named-axioms.json new file mode 100644 index 0000000..41676d1 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/001/named-axioms.json @@ -0,0 +1,62 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Consumer.shared_campaign_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Diagnostic.first_owner_not_last_writer": [ + "propext" + ], + "MAT009.Diagnostic.scan_first_owner_sticky": [ + "propext" + ], + "MAT009.M009_R1_initial": [ + "propext" + ], + "MAT009.M009_R2_assignment_overwrite": [ + "propext" + ], + "MAT009.M009_R3_cross_role_trigger": [], + "MAT009.M009_R4_stickiness": [], + "MAT009.M009_R5_final_set_intersection": [ + "propext" + ], + "MAT009.M009_R5_parent_union": [ + "propext" + ], + "MAT009.M009_R6_arbitrary_finite_scan": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_cross_trigger_in_finite_scan": [ + "propext" + ], + "MAT009.M009_R6_final_leakage_iff": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_latest_owner": [ + "propext" + ], + "MAT009.M009_R6_parent_reason_survives": [], + "MAT009.M009_R7_accepted_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_nonvacuous": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_rejected_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ] +} diff --git a/formal/sonification/mat009/lean/attempts/001/result.json b/formal/sonification/mat009/lean/attempts/001/result.json new file mode 100644 index 0000000..99e92a3 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/001/result.json @@ -0,0 +1,23 @@ +{ + "AUDIT_ACCEPTED": "OPEN", + "DIFFERENTIAL_TESTED": "NOT_EXECUTED", + "MODEL_PROVED": "NOT_EXECUTED", + "REFINEMENT_PROVED": "OPEN", + "baseline_commit": "bc5c6cb73a00df0bf9189075b776c4a5a78888bf", + "completed_utc": "2026-11-10T00:59:32.057933+00:00", + "error": "imported proof module coverage mismatch: ['DiagnosticFirstOwner', 'ExactTypes', 'SplitModel', 'TypedConsumer', 'formal.sonification.mat009.lean.LeanAudit']", + "input_sha256": { + "DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "LeanAudit.lean": "7aeabffbd65357e4ea41d773950bc7b52c892c5347b259f51d6a3831296aced8", + "PROOF_NOTES.md": "a7ffee569eab69bf4349fa6db14df5fae9e19164148d6711344080d2e6b53020", + "SplitModel.lean": "2d6f80e9749e846db5f7c54bcc189c1ae3f345e19677842c002c2bea69790795", + "TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa", + "check.py": "9dadb76da2dd3a9ff8fed85ae85b468286bb294986dfcec8d62edf2893476fbc", + "lean-toolchain": "55e97be96000b5e9e290c9e74482e5e317861499a5540353ce845471bded8cea" + }, + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "lean_version": "Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release)", + "started_utc": "2026-11-10T00:59:12.443505+00:00", + "status": "FAIL" +} diff --git a/formal/sonification/mat009/lean/check.py b/formal/sonification/mat009/lean/check.py index 4c61b3c..95e3d44 100644 --- a/formal/sonification/mat009/lean/check.py +++ b/formal/sonification/mat009/lean/check.py @@ -230,10 +230,10 @@ def main() -> int: for number, module in enumerate(MODULES): argv = [ str(lean), "--error=warning", "-o", - str(build / f"{module}.olean"), str(HERE / f"{module}.lean"), + str(build / f"{module}.olean"), f"{module}.lean", ] code, stdout, _, timeout = record_command( - out, f"build-{number:02d}-{module}", argv, cwd=ROOT, env=env + out, f"build-{number:02d}-{module}", argv, cwd=HERE, env=env ) if timeout or code != 0: raise ValueError(f"Lean rejected or timed out on {module}") From 62605e84b145f664a970ae09f17d9447d6c0268a Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:30:48 +1030 Subject: [PATCH 07/22] formal(mat009): retain source-pinned Lean proof execution --- .../attempts/002/build-00-SplitModel.json | 15 + .../attempts/002/build-00-SplitModel.stderr | 0 .../attempts/002/build-00-SplitModel.stdout | 0 .../002/build-01-DiagnosticFirstOwner.json | 15 + .../002/build-01-DiagnosticFirstOwner.stderr | 0 .../002/build-01-DiagnosticFirstOwner.stdout | 0 .../attempts/002/build-02-TypedConsumer.json | 15 + .../002/build-02-TypedConsumer.stderr | 0 .../002/build-02-TypedConsumer.stdout | 71 + .../attempts/002/build-03-ExactTypes.json | 15 + .../attempts/002/build-03-ExactTypes.stderr | 0 .../attempts/002/build-03-ExactTypes.stdout | 0 .../lean/attempts/002/build-04-LeanAudit.json | 15 + .../attempts/002/build-04-LeanAudit.stderr | 0 .../attempts/002/build-04-LeanAudit.stdout | 1664 ++++++ .../lean/attempts/002/declarations.json | 3321 +++++++++++ .../lean/attempts/002/lean-version.json | 12 + .../lean/attempts/002/lean-version.stderr | 0 .../lean/attempts/002/lean-version.stdout | 1 + .../lean/attempts/002/named-axioms.json | 62 + .../mat009/lean/attempts/002/result.json | 55 + .../lean/attempts/002/theorem-types.json | 24 + .../lean/attempts/002/toolchain-imports.json | 5214 +++++++++++++++++ 23 files changed, 10499 insertions(+) create mode 100644 formal/sonification/mat009/lean/attempts/002/build-00-SplitModel.json create mode 100644 formal/sonification/mat009/lean/attempts/002/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/attempts/002/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/attempts/002/build-01-DiagnosticFirstOwner.json create mode 100644 formal/sonification/mat009/lean/attempts/002/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/attempts/002/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/attempts/002/build-02-TypedConsumer.json create mode 100644 formal/sonification/mat009/lean/attempts/002/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/attempts/002/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/attempts/002/build-03-ExactTypes.json create mode 100644 formal/sonification/mat009/lean/attempts/002/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/lean/attempts/002/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/lean/attempts/002/build-04-LeanAudit.json create mode 100644 formal/sonification/mat009/lean/attempts/002/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/lean/attempts/002/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/lean/attempts/002/declarations.json create mode 100644 formal/sonification/mat009/lean/attempts/002/lean-version.json create mode 100644 formal/sonification/mat009/lean/attempts/002/lean-version.stderr create mode 100644 formal/sonification/mat009/lean/attempts/002/lean-version.stdout create mode 100644 formal/sonification/mat009/lean/attempts/002/named-axioms.json create mode 100644 formal/sonification/mat009/lean/attempts/002/result.json create mode 100644 formal/sonification/mat009/lean/attempts/002/theorem-types.json create mode 100644 formal/sonification/mat009/lean/attempts/002/toolchain-imports.json diff --git a/formal/sonification/mat009/lean/attempts/002/build-00-SplitModel.json b/formal/sonification/mat009/lean/attempts/002/build-00-SplitModel.json new file mode 100644 index 0000000..4bdb01e --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/build-00-SplitModel.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/002/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/attempts/002/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/002/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/attempts/002/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/002/build-01-DiagnosticFirstOwner.json b/formal/sonification/mat009/lean/attempts/002/build-01-DiagnosticFirstOwner.json new file mode 100644 index 0000000..0550d4e --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/build-01-DiagnosticFirstOwner.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/002/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/attempts/002/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/002/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/attempts/002/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/002/build-02-TypedConsumer.json b/formal/sonification/mat009/lean/attempts/002/build-02-TypedConsumer.json new file mode 100644 index 0000000..ca5d4d0 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/build-02-TypedConsumer.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/002/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/attempts/002/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/002/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/attempts/002/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/attempts/002/build-03-ExactTypes.json b/formal/sonification/mat009/lean/attempts/002/build-03-ExactTypes.json new file mode 100644 index 0000000..68500a4 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/build-03-ExactTypes.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/002/build-03-ExactTypes.stderr b/formal/sonification/mat009/lean/attempts/002/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/002/build-03-ExactTypes.stdout b/formal/sonification/mat009/lean/attempts/002/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/002/build-04-LeanAudit.json b/formal/sonification/mat009/lean/attempts/002/build-04-LeanAudit.json new file mode 100644 index 0000000..16c555a --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/build-04-LeanAudit.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "21d9dcb639ded4b2c3047045038ff0d3a3c216f2c1f57554d0832fb81e7042cc", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/002/build-04-LeanAudit.stderr b/formal/sonification/mat009/lean/attempts/002/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/002/build-04-LeanAudit.stdout b/formal/sonification/mat009/lean/attempts/002/build-04-LeanAudit.stdout new file mode 100644 index 0000000..cbccb8f --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/build-04-LeanAudit.stdout @@ -0,0 +1,1664 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.initial","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._closed_1._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.initial._elambda_1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.initial.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_3","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_4","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRow","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._closed_1._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.lastRole [] x = none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_2._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.leakageReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.leakageReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.noParent","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.noParent x = False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.noParent.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout ∧\n s.campaigns MAT009.Role.train \"SAME\" ∧ s.campaigns MAT009.Role.holdout \"SAME\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.overwrite_retains_both_split_memberships","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason ∧ ¬(MAT009.finalize s).childReason MAT009.leakageReason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_can_supply_leakage_reason","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (reason : String), s.parent reason → (MAT009.finalize s).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_reason_survives_finalization","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.scan s [] = s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_append","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key ↔\n s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), s.crossed → (MAT009.scan s rows).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_crossed_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.scan s rows)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_familyLeakage_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key ↔ s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_owner_last","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason ↔ s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.Role → String → Prop) → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.splitIntersection","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (members : MAT009.Role → String → Prop),\n MAT009.splitIntersection members = ∃ key, members MAT009.Role.train key ∧ members MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.splitIntersection.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.step","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.step._elambda_1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key ∨ role = row.role ∧ key = row.campaign,\n labs := fun role key => s.labs role key ∨ role = row.role ∧ key = row.lab,\n crossed := s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role,\n parent := s.parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.step.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String × MAT009.Diagnostic.Owner)) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (x : String) (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_15._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_16._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_17._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_18._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_19._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_20._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_21._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_AUDIT declarations=351 theorems=95 diff --git a/formal/sonification/mat009/lean/attempts/002/declarations.json b/formal/sonification/mat009/lean/attempts/002/declarations.json new file mode 100644 index 0000000..8fd605c --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/declarations.json @@ -0,0 +1,3321 @@ +[ + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Consumer.parent_reason_blocks_any_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "TypedConsumer", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Consumer.shared_campaign_blocks_any_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "TypedConsumer", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = campaign) \u2192\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = campaign) \u2192\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.Owner", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.Registry", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (x : String), MAT009.Diagnostic.empty x = none", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.first_owner_not_last_writer", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 String \u2192 MAT009.Diagnostic.Owner \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 String \u2192 MAT009.Diagnostic.Owner \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : Option MAT009.Diagnostic.Owner \u2192 Sort u_1) \u2192\n (x : Option MAT009.Diagnostic.Owner) \u2192\n (Unit \u2192 motive none) \u2192 ((first : MAT009.Diagnostic.Owner) \u2192 motive (some first)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : Option MAT009.Diagnostic.Owner \u2192 Sort u_1) \u2192\n (x : Option MAT009.Diagnostic.Owner) \u2192\n (Unit \u2192 motive none) \u2192 ((first : MAT009.Diagnostic.Owner) \u2192 motive (some first)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_first_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first \u2192 MAT009.Diagnostic.register registry identity candidate identity = some first", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_new_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none \u2192 MAT009.Diagnostic.register registry identity candidate identity = some candidate", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_other_identity", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key \u2260 identity \u2192 MAT009.Diagnostic.register registry identity candidate key = registry key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_preserves_existing", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.register registry identity candidate key = some first", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n (Unit \u2192 motive []) \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n (Unit \u2192 motive []) \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.scan_first_owner_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (updates : List (String \u00d7 MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.scan registry updates key = some first", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n (t : MAT009.Final) \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.childReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.childReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason \u2227 f.crossed \u2228 reason = MAT009.leakageReason \u2227 f.leakage)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.crossed", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.hasReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.hasReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason \u2228 f.childReason reason)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.leakage", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 Prop \u2192 Prop \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 Prop \u2192 Prop \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } \u2192\n parent = parent_1 \u2227 crossed = crossed_1 \u2227 leakage = leakage_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Final.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 \u2227 crossed = crossed_1 \u2227 leakage = leakage_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.Final} \u2192 v1 = v2 \u2192 MAT009.Final.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.Final \u2192 MAT009.Final \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.parent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n (t : MAT009.Final) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n (t : MAT009.Final) \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final),\n f.status = if \u2203 reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status_blocked_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final), f.status = MAT009.Status.blocked \u2194 \u2203 reason, f.hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status_structural_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated \u2194 \u2200 (reason : String), \u00acf.hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Final.status_structural_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {p : \u03b1 \u2192 Prop}, (\u00ac\u2203 x, p x) = \u2200 (x : \u03b1), \u00acp x", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R1_initial", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none \u2227\n \u00ac(MAT009.initial parent).campaigns role campaign \u2227\n \u00ac(MAT009.initial parent).labs role lab \u2227\n \u00ac(MAT009.initial parent).crossed \u2227 ((MAT009.initial parent).parent reason \u2194 parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R2_assignment_overwrite", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role \u2227\n (\u2200 (key : String), key \u2260 row.campaign \u2192 (MAT009.step s row).owner key = s.owner key) \u2227\n (\u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key \u2194 s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign) \u2227\n \u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key \u2194 s.labs role key \u2228 role = row.role \u2227 key = row.lab", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R3_cross_role_trigger", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed \u2194 s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R4_stickiness", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign \u2192 (MAT009.step s row).campaigns role campaign) \u2227\n (s.labs role lab \u2192 (MAT009.step s row).labs role lab) \u2227\n (s.crossed \u2192 (MAT009.step s row).crossed) \u2227\n (MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)) \u2227\n ((MAT009.step s row).parent reason \u2194 s.parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R5_final_set_intersection", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason \u2194\n (\u2203 key, s.campaigns MAT009.Role.train key \u2227 s.campaigns MAT009.Role.holdout key) \u2228\n \u2203 key, s.labs MAT009.Role.train key \u2227 s.labs MAT009.Role.holdout key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R5_parent_union", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason \u2194 s.parent MAT009.leakageReason \u2228 MAT009.familyLeakage s", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign \u2194\n \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = campaign) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab \u2194 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = lab) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).parent reason \u2194 parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_cross_trigger_in_finite_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (\u2203 previous, (MAT009.scan s before).owner row.campaign = some previous \u2227 previous \u2260 row.role) \u2192\n (MAT009.scan s (before ++ row :: after)).crossed", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason \u2194\n (\u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = key) \u2228\n \u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.lab = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.lab = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_latest_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R6_parent_reason_survives", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_accepted_example", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_nonvacuous", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(\u2203 rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) \u2227\n \u2203 rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_rejected_example", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.ReasonSet", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 (t : MAT009.Role) \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.holdout", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.holdout.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Role.holdout = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Role} \u2192 x = y \u2192 MAT009.Role.noConfusionType P x y", + "unsafe_definition": false + }, + { + "axioms": [ + "lcUnreachable" + ], + "declaration": "MAT009.Role.noConfusion._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Role} \u2192 x = y \u2192 MAT009.Role.noConfusionType P x y", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 _neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._lambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort v\u271d \u2192 MAT009.Role \u2192 MAT009.Role \u2192 Sort v\u271d", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat_toCtorIdx", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 (t : MAT009.Role) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 (t : MAT009.Role) \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.train", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.train.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Role.train = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.campaign", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n (t : MAT009.Row) \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.lab", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String \u2192 String \u2192 MAT009.Role \u2192 MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String \u2192 String \u2192 MAT009.Role \u2192 MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } \u2192\n campaign = campaign_1 \u2227 lab = lab_1 \u2227 role = role_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Row.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 \u2227 lab = lab_1 \u2227 role = role_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.Row} \u2192 v1 = v2 \u2192 MAT009.Row.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.Row \u2192 MAT009.Row \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n (t : MAT009.Row) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n (t : MAT009.Row) \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.role", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.campaigns", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Role \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n (t : MAT009.State) \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.crossed", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.labs", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Role \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(String \u2192 Option MAT009.Role) \u2192\n (MAT009.Role \u2192 String \u2192 Prop) \u2192 (MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop \u2192 MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(String \u2192 Option MAT009.Role) \u2192\n (MAT009.Role \u2192 String \u2192 Prop) \u2192 (MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop \u2192 MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {owner : String \u2192 Option MAT009.Role} {campaigns labs : MAT009.Role \u2192 String \u2192 Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String \u2192 Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role \u2192 String \u2192 Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } \u2192\n owner = owner_1 \u2227 campaigns = campaigns_1 \u2227 labs = labs_1 \u2227 crossed = crossed_1 \u2227 parent = parent_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.State.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (owner : String \u2192 Option MAT009.Role) (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String \u2192 Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role \u2192 String \u2192 Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 \u2227 campaigns = campaigns_1 \u2227 labs = labs_1 \u2227 crossed = crossed_1 \u2227 parent = parent_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (owner : String \u2192 Option MAT009.Role) (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.State} \u2192 v1 = v2 \u2192 MAT009.State.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.State \u2192 MAT009.State \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.owner", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.parent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n (t : MAT009.State) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n (t : MAT009.State) \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.blocked", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.blocked.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Status.blocked = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n (t : MAT009.Status) \u2192 motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Status} \u2192 x = y \u2192 MAT009.Status.noConfusionType P x y", + "unsafe_definition": false + }, + { + "axioms": [ + "lcUnreachable" + ], + "declaration": "MAT009.Status.noConfusion._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Status} \u2192 x = y \u2192 MAT009.Status.noConfusionType P x y", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 _neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort v\u271d \u2192 MAT009.Status \u2192 MAT009.Status \u2192 Sort v\u271d", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat_toCtorIdx", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 (t : MAT009.Status) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n (t : MAT009.Status) \u2192 motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.structuralOnlyUnauthenticated", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns \u2228 MAT009.splitIntersection s.labs)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage_step_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.finalize", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.finalize._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Final", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.finalize._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.finalize.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.initial", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._elambda_1", + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.initial._elambda_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.initial._elambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.initial.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [ + "lcProof" + ], + "declaration": "MAT009.instDecidableEqRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._proof_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx \u2192 x = y", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._proof_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Role), \u00acx.toCtorIdx = y.toCtorIdx \u2192 x = y \u2192 False", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [ + "lcProof" + ], + "declaration": "MAT009.instDecidableEqStatus._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._proof_3", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx \u2192 x = y", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._proof_4", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Status), \u00acx.toCtorIdx = y.toCtorIdx \u2192 x = y \u2192 False", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String), MAT009.lastRole [] x = none", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : Option MAT009.Role \u2192 Sort u_1) \u2192\n (x : Option MAT009.Role) \u2192 ((role : MAT009.Role) \u2192 motive (some role)) \u2192 (Unit \u2192 motive none) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : Option MAT009.Role \u2192 Sort u_1) \u2192\n (x : Option MAT009.Role) \u2192 ((role : MAT009.Role) \u2192 motive (some role)) \u2192 (Unit \u2192 motive none) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_2", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_2._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.noParent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.noParent._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.ReasonSet", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.noParent._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.noParent.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String), MAT009.noParent x = False", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.overwrite_retains_both_split_memberships", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout \u2227\n s.campaigns MAT009.Role.train \"SAME\" \u2227 s.campaigns MAT009.Role.holdout \"SAME\"", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.parent_can_supply_leakage_reason", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason \u2227 \u00ac(MAT009.finalize s).childReason MAT009.leakageReason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.parent_reason_survives_finalization", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (reason : String), s.parent reason \u2192 (MAT009.finalize s).hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.scan._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.scan._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State), MAT009.scan s [] = s", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (Unit \u2192 motive []) \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (Unit \u2192 motive []) \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.scan_append", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key \u2194\n s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {a b : \u03b1}, (a = b) = (b = a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, ((a \u2228 b) \u2228 c) = (a \u2228 b \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, (a \u2228 b \u2228 c) = (b \u2228 a \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_8", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b : Prop}, (a \u2228 b) = (b \u2228 a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_crossed_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row), s.crossed \u2192 (MAT009.scan s rows).crossed", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_familyLeakage_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.scan s rows)", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.scan_labs_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key \u2194 s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {a b : \u03b1}, (a = b) = (b = a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, ((a \u2228 b) \u2228 c) = (a \u2228 b \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, (a \u2228 b \u2228 c) = (b \u2228 a \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_8", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b : Prop}, (a \u2228 b) = (b \u2228 a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_owner_last", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan_parent", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason \u2194 s.parent reason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.splitIntersection", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.splitIntersection.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (members : MAT009.Role \u2192 String \u2192 Prop),\n MAT009.splitIntersection members = \u2203 key, members MAT009.Role.train key \u2227 members MAT009.Role.holdout key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.step", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._elambda_1", + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.step._elambda_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.step._elambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.step.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign,\n labs := fun role key => s.labs role key \u2228 role = row.role \u2227 key = row.lab,\n crossed := s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role,\n parent := s.parent }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) (h_1 : Unit \u2192 motive [])\n (h_2 :\n (identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) (h_1 : Unit \u2192 motive [])\n (h_2 :\n (identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n motive [] \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n motive [] \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 String \u2192 Sort u_1) (x : String) (h_1 : (x : String) \u2192 motive [] x)\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 String \u2192 Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) \u2192 motive [] x)\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : MAT009.Role \u2192 Sort u_1) \u2192\n (x : MAT009.Role) \u2192 (Unit \u2192 motive MAT009.Role.train) \u2192 (Unit \u2192 motive MAT009.Role.holdout) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.match_1.\u00ab_@\u00bb.SplitModel._hyg.109._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : MAT009.Role \u2192 Sort u_1) \u2192\n (x : MAT009.Role) \u2192 (Unit \u2192 motive MAT009.Role.train) \u2192 (Unit \u2192 motive MAT009.Role.holdout) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_13._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_14._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_13._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_14._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_15._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_16._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_17._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_18._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_19._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_20._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_21._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : MAT009.Status \u2192 Sort u_1) \u2192\n (x : MAT009.Status) \u2192\n (Unit \u2192 motive MAT009.Status.blocked) \u2192 (Unit \u2192 motive MAT009.Status.structuralOnlyUnauthenticated) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.match_1.\u00ab_@\u00bb.SplitModel._hyg.882._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : MAT009.Status \u2192 Sort u_1) \u2192\n (x : MAT009.Status) \u2192\n (Unit \u2192 motive MAT009.Status.blocked) \u2192 (Unit \u2192 motive MAT009.Status.structuralOnlyUnauthenticated) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 Sort u_1) (h_1 : Unit \u2192 motive [])\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit \u2192 motive [])\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192 motive [] \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192 motive [] \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + } +] diff --git a/formal/sonification/mat009/lean/attempts/002/lean-version.json b/formal/sonification/mat009/lean/attempts/002/lean-version.json new file mode 100644 index 0000000..10f4b46 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/lean-version.json @@ -0,0 +1,12 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--version" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b", + "timed_out": false, + "timeout_seconds": 30 +} diff --git a/formal/sonification/mat009/lean/attempts/002/lean-version.stderr b/formal/sonification/mat009/lean/attempts/002/lean-version.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/002/lean-version.stdout b/formal/sonification/mat009/lean/attempts/002/lean-version.stdout new file mode 100644 index 0000000..507e58d --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/lean-version.stdout @@ -0,0 +1 @@ +Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release) diff --git a/formal/sonification/mat009/lean/attempts/002/named-axioms.json b/formal/sonification/mat009/lean/attempts/002/named-axioms.json new file mode 100644 index 0000000..41676d1 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/named-axioms.json @@ -0,0 +1,62 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Consumer.shared_campaign_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Diagnostic.first_owner_not_last_writer": [ + "propext" + ], + "MAT009.Diagnostic.scan_first_owner_sticky": [ + "propext" + ], + "MAT009.M009_R1_initial": [ + "propext" + ], + "MAT009.M009_R2_assignment_overwrite": [ + "propext" + ], + "MAT009.M009_R3_cross_role_trigger": [], + "MAT009.M009_R4_stickiness": [], + "MAT009.M009_R5_final_set_intersection": [ + "propext" + ], + "MAT009.M009_R5_parent_union": [ + "propext" + ], + "MAT009.M009_R6_arbitrary_finite_scan": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_cross_trigger_in_finite_scan": [ + "propext" + ], + "MAT009.M009_R6_final_leakage_iff": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_latest_owner": [ + "propext" + ], + "MAT009.M009_R6_parent_reason_survives": [], + "MAT009.M009_R7_accepted_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_nonvacuous": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_rejected_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ] +} diff --git a/formal/sonification/mat009/lean/attempts/002/result.json b/formal/sonification/mat009/lean/attempts/002/result.json new file mode 100644 index 0000000..cb922b8 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/result.json @@ -0,0 +1,55 @@ +{ + "AUDIT_ACCEPTED": "OPEN", + "DIFFERENTIAL_TESTED": "NOT_EXECUTED", + "MODEL_PROVED": "PASS_FOR_SCOPED_MATHEMATICAL_MODEL", + "REFINEMENT_PROVED": "OPEN", + "baseline_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "compiler_auxiliary_count": 146, + "completed_utc": "2026-11-10T01:00:17.065909+00:00", + "declaration_count": 351, + "external_import_count": 1303, + "input_sha256": { + "DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "LeanAudit.lean": "7aeabffbd65357e4ea41d773950bc7b52c892c5347b259f51d6a3831296aced8", + "PROOF_NOTES.md": "660493388f779bd1fc38a30a8051596e05985250e08b5f51e5c226da7e354cbf", + "SplitModel.lean": "2d6f80e9749e846db5f7c54bcc189c1ae3f345e19677842c002c2bea69790795", + "TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa", + "check.py": "125041442f582e7fc254dc341926b4cfb935ac964057c930021366a950a5a108", + "lean-toolchain": "55e97be96000b5e9e290c9e74482e5e317861499a5540353ce845471bded8cea" + }, + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "lean_version": "Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release)", + "logical_axioms": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "named_intended_theorems": [ + "MAT009.Consumer.parent_reason_blocks_any_scan", + "MAT009.Consumer.shared_campaign_blocks_any_scan", + "MAT009.Diagnostic.first_owner_not_last_writer", + "MAT009.Diagnostic.register_first_owner", + "MAT009.Diagnostic.register_new_owner", + "MAT009.Diagnostic.register_other_identity", + "MAT009.Diagnostic.register_preserves_existing", + "MAT009.Diagnostic.scan_first_owner_sticky", + "MAT009.M009_R1_initial", + "MAT009.M009_R2_assignment_overwrite", + "MAT009.M009_R3_cross_role_trigger", + "MAT009.M009_R4_stickiness", + "MAT009.M009_R5_final_set_intersection", + "MAT009.M009_R5_parent_union", + "MAT009.M009_R6_arbitrary_finite_scan", + "MAT009.M009_R6_cross_trigger_in_finite_scan", + "MAT009.M009_R6_final_leakage_iff", + "MAT009.M009_R6_latest_owner", + "MAT009.M009_R6_parent_reason_survives", + "MAT009.M009_R7_accepted_example", + "MAT009.M009_R7_nonvacuous", + "MAT009.M009_R7_rejected_example" + ], + "started_utc": "2026-11-10T00:59:57.311697+00:00", + "status": "PASS", + "theorem_declaration_count_including_generated": 95 +} diff --git a/formal/sonification/mat009/lean/attempts/002/theorem-types.json b/formal/sonification/mat009/lean/attempts/002/theorem-types.json new file mode 100644 index 0000000..1eb358e --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/theorem-types.json @@ -0,0 +1,24 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "MAT009.Consumer.shared_campaign_blocks_any_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = campaign) \u2192\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = campaign) \u2192\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "MAT009.Diagnostic.first_owner_not_last_writer": "MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")", + "MAT009.Diagnostic.register_first_owner": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first \u2192 MAT009.Diagnostic.register registry identity candidate identity = some first", + "MAT009.Diagnostic.register_new_owner": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none \u2192 MAT009.Diagnostic.register registry identity candidate identity = some candidate", + "MAT009.Diagnostic.register_other_identity": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key \u2260 identity \u2192 MAT009.Diagnostic.register registry identity candidate key = registry key", + "MAT009.Diagnostic.register_preserves_existing": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.register registry identity candidate key = some first", + "MAT009.Diagnostic.scan_first_owner_sticky": "\u2200 (registry : MAT009.Diagnostic.Registry) (updates : List (String \u00d7 MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.scan registry updates key = some first", + "MAT009.M009_R1_initial": "\u2200 (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none \u2227\n \u00ac(MAT009.initial parent).campaigns role campaign \u2227\n \u00ac(MAT009.initial parent).labs role lab \u2227\n \u00ac(MAT009.initial parent).crossed \u2227 ((MAT009.initial parent).parent reason \u2194 parent reason)", + "MAT009.M009_R2_assignment_overwrite": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role \u2227\n (\u2200 (key : String), key \u2260 row.campaign \u2192 (MAT009.step s row).owner key = s.owner key) \u2227\n (\u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key \u2194 s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign) \u2227\n \u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key \u2194 s.labs role key \u2228 role = row.role \u2227 key = row.lab", + "MAT009.M009_R3_cross_role_trigger": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed \u2194 s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role", + "MAT009.M009_R4_stickiness": "\u2200 (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign \u2192 (MAT009.step s row).campaigns role campaign) \u2227\n (s.labs role lab \u2192 (MAT009.step s row).labs role lab) \u2227\n (s.crossed \u2192 (MAT009.step s row).crossed) \u2227\n (MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)) \u2227\n ((MAT009.step s row).parent reason \u2194 s.parent reason)", + "MAT009.M009_R5_final_set_intersection": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason \u2194\n (\u2203 key, s.campaigns MAT009.Role.train key \u2227 s.campaigns MAT009.Role.holdout key) \u2228\n \u2203 key, s.labs MAT009.Role.train key \u2227 s.labs MAT009.Role.holdout key", + "MAT009.M009_R5_parent_union": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason \u2194 s.parent MAT009.leakageReason \u2228 MAT009.familyLeakage s", + "MAT009.M009_R6_arbitrary_finite_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign \u2194\n \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = campaign) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab \u2194 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = lab) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).parent reason \u2194 parent reason)", + "MAT009.M009_R6_cross_trigger_in_finite_scan": "\u2200 (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (\u2203 previous, (MAT009.scan s before).owner row.campaign = some previous \u2227 previous \u2260 row.role) \u2192\n (MAT009.scan s (before ++ row :: after)).crossed", + "MAT009.M009_R6_final_leakage_iff": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason \u2194\n (\u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = key) \u2228\n \u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.lab = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.lab = key", + "MAT009.M009_R6_latest_owner": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign", + "MAT009.M009_R6_parent_reason_survives": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason", + "MAT009.M009_R7_accepted_example": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated", + "MAT009.M009_R7_nonvacuous": "(\u2203 rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) \u2227\n \u2203 rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked", + "MAT009.M009_R7_rejected_example": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked" +} diff --git a/formal/sonification/mat009/lean/attempts/002/toolchain-imports.json b/formal/sonification/mat009/lean/attempts/002/toolchain-imports.json new file mode 100644 index 0000000..e56b85e --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/toolchain-imports.json @@ -0,0 +1,5214 @@ +{ + "Init": { + "relative_path": "lib/lean/Init.olean", + "sha256": "f14f6c9ea0d9eb2a6fe7bdad84a6610657db3d006805708c1a62ac72b676e944" + }, + "Init.BinderNameHint": { + "relative_path": "lib/lean/Init/BinderNameHint.olean", + "sha256": "87ad3f24763ab6293e9907bd53fd2c87397a1bcc41741d496530391424f397f0" + }, + "Init.BinderPredicates": { + "relative_path": "lib/lean/Init/BinderPredicates.olean", + "sha256": "b87d6204d662e2164c4ccac16ffe6ef34c17e46473219f7615a8e5a902f88399" + }, + "Init.ByCases": { + "relative_path": "lib/lean/Init/ByCases.olean", + "sha256": "a446cd54c7d9b5cd764bac51e0e86bdbfd92cceb559a0ce174c8bfdd0880031f" + }, + "Init.Classical": { + "relative_path": "lib/lean/Init/Classical.olean", + "sha256": "146557a1d2b3d89dccc8a37db0eaf2ca41b7e8b7e9699cc1d2040209ab2d5206" + }, + "Init.Coe": { + "relative_path": "lib/lean/Init/Coe.olean", + "sha256": "8264daae9323339b7a0e4648e9054bc4d6bfa2ed2efe3bbf60f3ed4c85ededf1" + }, + "Init.Control": { + "relative_path": "lib/lean/Init/Control.olean", + "sha256": "02b03cb26d015878cb086d2aa9619d028653c4d7b13f7d27defa18c526f59acf" + }, + "Init.Control.Basic": { + "relative_path": "lib/lean/Init/Control/Basic.olean", + "sha256": "770f96586bd33c585cba7ae023b9ba455fdbcc6656008a7ae44921a2a381e673" + }, + "Init.Control.EState": { + "relative_path": "lib/lean/Init/Control/EState.olean", + "sha256": "bf304f9ebac42bc1e0604ed85fd34ccfbfb1d48c36a0378264daa004c7b1663a" + }, + "Init.Control.Except": { + "relative_path": "lib/lean/Init/Control/Except.olean", + "sha256": "2df44aacfe3c18de279a500ce89ca07fdaae3ac41ee5e13753f675ffcee590bf" + }, + "Init.Control.ExceptCps": { + "relative_path": "lib/lean/Init/Control/ExceptCps.olean", + "sha256": "abf85a131ec12cc4943351cd8e94d25a8ea643d8aed05e3174ddf102a92c82ab" + }, + "Init.Control.Id": { + "relative_path": "lib/lean/Init/Control/Id.olean", + "sha256": "3bdbaf6aab9ebd5bc7f69df7ea3817d60fe3e93621ceac45998aeada2ab0f2fb" + }, + "Init.Control.Lawful": { + "relative_path": "lib/lean/Init/Control/Lawful.olean", + "sha256": "d0e4de63caa049aa63032c262df55cb6e05decd6a639b3197d03a94bfb9cf630" + }, + "Init.Control.Lawful.Basic": { + "relative_path": "lib/lean/Init/Control/Lawful/Basic.olean", + "sha256": "2e5796aeb855144054fe96c87df8c1942fe57363ca46616dd713602e9e83008e" + }, + "Init.Control.Lawful.Instances": { + "relative_path": "lib/lean/Init/Control/Lawful/Instances.olean", + "sha256": "3a42743efc08488094315361697052bbea44791dc9b26bb42a7687be82351798" + }, + "Init.Control.Lawful.Lemmas": { + "relative_path": "lib/lean/Init/Control/Lawful/Lemmas.olean", + "sha256": "872c79b884079a180f2cb4efe5d5ccfd86e8231040ccf0286fdc0ae3e48de6cb" + }, + "Init.Control.Option": { + "relative_path": "lib/lean/Init/Control/Option.olean", + "sha256": "2fd4fd3d76c35d38f22bbd43287b2034db3fc09e9db40a72d64766fc2e1a27cf" + }, + "Init.Control.Reader": { + "relative_path": "lib/lean/Init/Control/Reader.olean", + "sha256": "0ee81ccf6c24215ac02fbddbc47f9d0ec88154c747938db879dc176e84cab35c" + }, + "Init.Control.State": { + "relative_path": "lib/lean/Init/Control/State.olean", + "sha256": "9967249936b6e2882f7c6551ed25b8c11c499e5146884f43c851019a9212b58e" + }, + "Init.Control.StateCps": { + "relative_path": "lib/lean/Init/Control/StateCps.olean", + "sha256": "a7e465f72965884c566492bf128ce366f9b6259feb3ff78a2dc7941276668910" + }, + "Init.Control.StateRef": { + "relative_path": "lib/lean/Init/Control/StateRef.olean", + "sha256": "4c48d97631e2c887a9109f0a3b11930e960674722db2d7ec96228ebb4cebc397" + }, + "Init.Conv": { + "relative_path": "lib/lean/Init/Conv.olean", + "sha256": "27e368664cd48cc7db0b6d8b936fcf3bd3b0c8652d67c7d72ed1a70e481c2cae" + }, + "Init.Core": { + "relative_path": "lib/lean/Init/Core.olean", + "sha256": "325d3e1934d1e99dbf7bde7643d6b1a582e0e98a2bc67156ecbfb1e044c81b62" + }, + "Init.Data": { + "relative_path": "lib/lean/Init/Data.olean", + "sha256": "e0fb356d8ff226c74733d563a2fddfd5d3f9031353f07eab9316189729ea0b05" + }, + "Init.Data.AC": { + "relative_path": "lib/lean/Init/Data/AC.olean", + "sha256": "c31d122ca9a36ebccfade139b5d01a27520cfe5da9c13fbcee0de6afc18e6e2e" + }, + "Init.Data.Array": { + "relative_path": "lib/lean/Init/Data/Array.olean", + "sha256": "628b1fe1e5028d01279c0e4b94f8a75a5404c5c2c62f56cb0f2f93e949b871fe" + }, + "Init.Data.Array.Attach": { + "relative_path": "lib/lean/Init/Data/Array/Attach.olean", + "sha256": "17dd10a433d8c5eefec2380008930b9db90cf5baaf6a111862d248280489809b" + }, + "Init.Data.Array.Basic": { + "relative_path": "lib/lean/Init/Data/Array/Basic.olean", + "sha256": "c1b3ecb3200b55fd9c0f508d6a70518cad1e6cd68e3333d6363ac275efa290b4" + }, + "Init.Data.Array.BasicAux": { + "relative_path": "lib/lean/Init/Data/Array/BasicAux.olean", + "sha256": "498f1b5994a45cd4303c9a5a1252d20f1706d7227fd6068a54a21102c4ecb49d" + }, + "Init.Data.Array.BinSearch": { + "relative_path": "lib/lean/Init/Data/Array/BinSearch.olean", + "sha256": "c8ffd80ccccd8119ba40ef890a3408310abd6535ecb282e8ecd8f8b943dad63a" + }, + "Init.Data.Array.Bootstrap": { + "relative_path": "lib/lean/Init/Data/Array/Bootstrap.olean", + "sha256": "d22a9ec6e5a01f844321cfd7ecfba9f02f0d15cffd6e7667315e36caaf2f4d5d" + }, + "Init.Data.Array.Count": { + "relative_path": "lib/lean/Init/Data/Array/Count.olean", + "sha256": "5cac2d9caf60f31946dcc2b3ecacde3f52d6c143dd91504af2245e9203360700" + }, + "Init.Data.Array.DecidableEq": { + "relative_path": "lib/lean/Init/Data/Array/DecidableEq.olean", + "sha256": "61699c7b47f0fe3ceabab22f86fad529d0c53c229168e2eb5a4c81b3b44161da" + }, + "Init.Data.Array.Erase": { + "relative_path": "lib/lean/Init/Data/Array/Erase.olean", + "sha256": "a39e0a7704569c26626a57596aa4838b835eb5940a90874febcd53aed46c3676" + }, + "Init.Data.Array.Extract": { + "relative_path": "lib/lean/Init/Data/Array/Extract.olean", + "sha256": "d3ae74a38b69aaf4e3f7cf247e3b51d97845035076f21c37f9516f17dec53115" + }, + "Init.Data.Array.FinRange": { + "relative_path": "lib/lean/Init/Data/Array/FinRange.olean", + "sha256": "ccdba2d4e97ed32f04ea6d66ffa24cd4667d3c17e923939d251b12b8c156ff0a" + }, + "Init.Data.Array.Find": { + "relative_path": "lib/lean/Init/Data/Array/Find.olean", + "sha256": "60374792eaf3e1c935911342aadc2e0fe2c2df226d1b2ffeead456d396242565" + }, + "Init.Data.Array.GetLit": { + "relative_path": "lib/lean/Init/Data/Array/GetLit.olean", + "sha256": "7500dfd2f61932caa3bb61dff522cea1d043f9d52f875df9ca9377cb5be6ae00" + }, + "Init.Data.Array.InsertIdx": { + "relative_path": "lib/lean/Init/Data/Array/InsertIdx.olean", + "sha256": "0885128103fece2609d3de7d95170ead99c2422e3b2611efc17ad64d13c54b93" + }, + "Init.Data.Array.InsertionSort": { + "relative_path": "lib/lean/Init/Data/Array/InsertionSort.olean", + "sha256": "00eeffee6c9c944e626b54aa1ba80e2817ee0d6d72a58b4504ed5d6150963199" + }, + "Init.Data.Array.Lemmas": { + "relative_path": "lib/lean/Init/Data/Array/Lemmas.olean", + "sha256": "6d70a718a88e0f5e3a2fbf58ab9a927086ecb80cc131ca4daf61b8373b29bc7e" + }, + "Init.Data.Array.Lex": { + "relative_path": "lib/lean/Init/Data/Array/Lex.olean", + "sha256": "dcfcf549b75b61784fc2761dd6ab27112a5f3f85635156ff45f17907241f873c" + }, + "Init.Data.Array.Lex.Basic": { + "relative_path": "lib/lean/Init/Data/Array/Lex/Basic.olean", + "sha256": "5099ffc811762f879efd0a8d2dc6a6f46b03aaf13e5d7198a40b028f84339f6a" + }, + "Init.Data.Array.Lex.Lemmas": { + "relative_path": "lib/lean/Init/Data/Array/Lex/Lemmas.olean", + "sha256": "edd3b29355f8877ba1d4baa7eb7191d19ec56b68e8caf7136e56562d46f2cf00" + }, + "Init.Data.Array.MapIdx": { + "relative_path": "lib/lean/Init/Data/Array/MapIdx.olean", + "sha256": "fa5fa7562d940a373cde8271701c1b1b6aa4ccc7685a7d8aee563bd6a531b023" + }, + "Init.Data.Array.Mem": { + "relative_path": "lib/lean/Init/Data/Array/Mem.olean", + "sha256": "6d8b81e87c3f6194010d50453930aef26a33d02836f577fdf528f96427fd2871" + }, + "Init.Data.Array.Monadic": { + "relative_path": "lib/lean/Init/Data/Array/Monadic.olean", + "sha256": "4c7ac2031c6b67e8904e378eab4f4e4e52a741464f759346c6bbadf358353040" + }, + "Init.Data.Array.OfFn": { + "relative_path": "lib/lean/Init/Data/Array/OfFn.olean", + "sha256": "269214e9ef1869f764ea7744d27f9bb5f2d88c06a199c35a523bcab485056514" + }, + "Init.Data.Array.Perm": { + "relative_path": "lib/lean/Init/Data/Array/Perm.olean", + "sha256": "df04ccb43fffbdfc14af5e01b9a288eba07cf33dfd934fefc7d3ee62380abbad" + }, + "Init.Data.Array.QSort": { + "relative_path": "lib/lean/Init/Data/Array/QSort.olean", + "sha256": "182e2fb5ccae0e4290f1df223f6da4fe8e4671735b1f8be5768f67aecd976a9b" + }, + "Init.Data.Array.Range": { + "relative_path": "lib/lean/Init/Data/Array/Range.olean", + "sha256": "470d0a04ec3f6acf4e1a4a17c0ac006ff4f4ca6a132e6fe75cb24a3422045edf" + }, + "Init.Data.Array.Set": { + "relative_path": "lib/lean/Init/Data/Array/Set.olean", + "sha256": "47765fffb2b0ff3eeb3b9fcdf1f872a1264fbecc6fd9fa3b3bcacb14305d21cc" + }, + "Init.Data.Array.Subarray": { + "relative_path": "lib/lean/Init/Data/Array/Subarray.olean", + "sha256": "a2b4eb8e9ff8708540ec1224bc150ec997f6b339fc526c8f905824dab5814eb1" + }, + "Init.Data.Array.Subarray.Split": { + "relative_path": "lib/lean/Init/Data/Array/Subarray/Split.olean", + "sha256": "e70f52b7a240f6f48ece84e6e5efe81be6f0aa59787d93877069acf4d299d6da" + }, + "Init.Data.Array.TakeDrop": { + "relative_path": "lib/lean/Init/Data/Array/TakeDrop.olean", + "sha256": "cb756a88720cd6633a931cc4cd278804391f1d4b6e7804fed40e0014f27250e4" + }, + "Init.Data.Array.Zip": { + "relative_path": "lib/lean/Init/Data/Array/Zip.olean", + "sha256": "57b72c19de8fc1a600d24da0a2ce3edc78620fc487668928f5092c62e6199bf8" + }, + "Init.Data.BEq": { + "relative_path": "lib/lean/Init/Data/BEq.olean", + "sha256": "fc264bbc09afcdee4cf301170287f97dce8426a1102c2c20a2b3324af470be03" + }, + "Init.Data.Basic": { + "relative_path": "lib/lean/Init/Data/Basic.olean", + "sha256": "320b6a318c7f47b88b4cc52a3dd10f1c253c4ba15882c0fba4d0b6cc8b258629" + }, + "Init.Data.BitVec": { + "relative_path": "lib/lean/Init/Data/BitVec.olean", + "sha256": "9806987569400445640812d3675deb3d56b79c12d42e8168aebba2d2d42ef3cd" + }, + "Init.Data.BitVec.Basic": { + "relative_path": "lib/lean/Init/Data/BitVec/Basic.olean", + "sha256": "263c59d8eecd1dca7acf46649c80ce9d7b5680064309b9eedc76d4ca02a03e34" + }, + "Init.Data.BitVec.BasicAux": { + "relative_path": "lib/lean/Init/Data/BitVec/BasicAux.olean", + "sha256": "1ba7804f2a9d1739a51b1e7dea3821a38743373b1072bf85c41d247cfa8bcbaa" + }, + "Init.Data.BitVec.Bitblast": { + "relative_path": "lib/lean/Init/Data/BitVec/Bitblast.olean", + "sha256": "c7663248b6910786438135f4eabd9f5fce7ddb61628c667345d04c4be6dda7b3" + }, + "Init.Data.BitVec.Folds": { + "relative_path": "lib/lean/Init/Data/BitVec/Folds.olean", + "sha256": "b4d4aa0cfd3f346fd1f6361552afcf5245668c55fd2d0ad1ebf467f841ae20d0" + }, + "Init.Data.BitVec.Lemmas": { + "relative_path": "lib/lean/Init/Data/BitVec/Lemmas.olean", + "sha256": "c11aebc16adf6f6fdd8d3a9dcb74b295034999579793c2f4eb79b044fccd618e" + }, + "Init.Data.Bool": { + "relative_path": "lib/lean/Init/Data/Bool.olean", + "sha256": "24c3fa2ac49e5f1681100130790a5f322bed745e47b503e25ff49b7a3c5f6d68" + }, + "Init.Data.ByteArray": { + "relative_path": "lib/lean/Init/Data/ByteArray.olean", + "sha256": "3c0fa93b6b78ea8b3733b02a83dca06a085b3938355811eee6c06cbdd0179a8e" + }, + "Init.Data.ByteArray.Basic": { + "relative_path": "lib/lean/Init/Data/ByteArray/Basic.olean", + "sha256": "f995de7efe27dc6573bf9cf32e2399ba4ee0659f0b64f07285bb15edbd8048fd" + }, + "Init.Data.Cast": { + "relative_path": "lib/lean/Init/Data/Cast.olean", + "sha256": "3413b2ca8a0098a6e572d7728ed1532eaa21ca10067197f3b214aeff2ccdd651" + }, + "Init.Data.Channel": { + "relative_path": "lib/lean/Init/Data/Channel.olean", + "sha256": "945114f1dd771f97d93cdac7466ff0ff1e0f1461bc4fda27b5f5b9715dcdc174" + }, + "Init.Data.Char": { + "relative_path": "lib/lean/Init/Data/Char.olean", + "sha256": "818aac23581c282c3f6d2f80775ac47ce6d31b55ce54b3d187b6ed4b8de8cc63" + }, + "Init.Data.Char.Basic": { + "relative_path": "lib/lean/Init/Data/Char/Basic.olean", + "sha256": "6ed0988e9f8e134dbc30d38ed257a44850e98d71b7d77d5a977f4297e085a0f1" + }, + "Init.Data.Char.Lemmas": { + "relative_path": "lib/lean/Init/Data/Char/Lemmas.olean", + "sha256": "030a6cdcb16360b9f90d072e40bd66ce8aafab43137dd9d03e82229ebec3ced9" + }, + "Init.Data.Fin": { + "relative_path": "lib/lean/Init/Data/Fin.olean", + "sha256": "e955ad0ee4c253aaf23086b1452740c2c9888c594b9c404bb34699868773dfe2" + }, + "Init.Data.Fin.Basic": { + "relative_path": "lib/lean/Init/Data/Fin/Basic.olean", + "sha256": "e4b2abb6d8a424da6e7ff21b0e71ead051c0605e76db3680888305ac128f5b55" + }, + "Init.Data.Fin.Bitwise": { + "relative_path": "lib/lean/Init/Data/Fin/Bitwise.olean", + "sha256": "e80029b17e55e5e4b917ef076545aa017bb7844bed24f7f3c376952d82f3e21b" + }, + "Init.Data.Fin.Fold": { + "relative_path": "lib/lean/Init/Data/Fin/Fold.olean", + "sha256": "8d618def1ed982a59898c72e714939d861836ea9f84fe4414677c4b7fac9295a" + }, + "Init.Data.Fin.Iterate": { + "relative_path": "lib/lean/Init/Data/Fin/Iterate.olean", + "sha256": "f6553fbf009244d2b848079f104ef424f9048ad5e5e45276169f58b674dbdf58" + }, + "Init.Data.Fin.Lemmas": { + "relative_path": "lib/lean/Init/Data/Fin/Lemmas.olean", + "sha256": "9fe597ce2f3edce6a67a4542d72bd0300cc643a484297fc8d61966a28b61935d" + }, + "Init.Data.Fin.Log2": { + "relative_path": "lib/lean/Init/Data/Fin/Log2.olean", + "sha256": "d4e9f3e05222a066c5fdc327065d7147d16a939ebcedf988b8e428bfd7a1d6a3" + }, + "Init.Data.Float": { + "relative_path": "lib/lean/Init/Data/Float.olean", + "sha256": "92478058b9b83eddef7ecea3797414d74db6e61e2b688e64ab7ba81df127b15a" + }, + "Init.Data.Float32": { + "relative_path": "lib/lean/Init/Data/Float32.olean", + "sha256": "2a37e1add33b9d6047350feaa9d87b913f1e58718bd5a3cb597d60e6573f9212" + }, + "Init.Data.FloatArray": { + "relative_path": "lib/lean/Init/Data/FloatArray.olean", + "sha256": "78c9b7500ea433aede3b8587af3bbbe727c8ebfd6f8a5942f6c0d14b0faa44b5" + }, + "Init.Data.FloatArray.Basic": { + "relative_path": "lib/lean/Init/Data/FloatArray/Basic.olean", + "sha256": "7169a26af51b7faaa9712ed85d9423a43b5c4f31ba4ccdbb3289eeaaf58e0afa" + }, + "Init.Data.Format": { + "relative_path": "lib/lean/Init/Data/Format.olean", + "sha256": "82528100ce60ae1eded58f45a0319b76ac7c80f9d834c60bec31cddd2a1f836b" + }, + "Init.Data.Format.Basic": { + "relative_path": "lib/lean/Init/Data/Format/Basic.olean", + "sha256": "7b7e7500d7a86ce98f996e4c6045c7fff49ee0efc72737cfc5ab4c284ad77f4a" + }, + "Init.Data.Format.Instances": { + "relative_path": "lib/lean/Init/Data/Format/Instances.olean", + "sha256": "b8bede2673426df8591cc8d2837854e12fd82f83132adcdb5d4fa6492b9f1d21" + }, + "Init.Data.Format.Macro": { + "relative_path": "lib/lean/Init/Data/Format/Macro.olean", + "sha256": "d4b42a5cd357e4c35a328183571bb8a919d2dba0e0241b081293c449b726ae35" + }, + "Init.Data.Format.Syntax": { + "relative_path": "lib/lean/Init/Data/Format/Syntax.olean", + "sha256": "3433640ca9aeb5ef96fda95bf9dc747d0feba236f3a3db2860f92970c5718882" + }, + "Init.Data.Function": { + "relative_path": "lib/lean/Init/Data/Function.olean", + "sha256": "17fa8cf9a33f44e97d1a3a8c77e086c567ef0520291421839b77b28fdbd2b8fa" + }, + "Init.Data.Hashable": { + "relative_path": "lib/lean/Init/Data/Hashable.olean", + "sha256": "0d9ba8712572cf7103ef0e4c1012f4c3d1b10bbc3f9d55409eb315ed87f26e7f" + }, + "Init.Data.Int": { + "relative_path": "lib/lean/Init/Data/Int.olean", + "sha256": "4628002a234694983f14e288745898d889aada1b0d9d9fbff5f3fb8dbb72c20a" + }, + "Init.Data.Int.Basic": { + "relative_path": "lib/lean/Init/Data/Int/Basic.olean", + "sha256": "926f11cf3beb5d66e06dc405f6aac7f39b38c440ba23baa26827ca79724b8eae" + }, + "Init.Data.Int.Bitwise": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise.olean", + "sha256": "527f601e3b6565c4e13a78e71c252c99f51b0203fba8e9a48bf61a6d702f7f77" + }, + "Init.Data.Int.Bitwise.Basic": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise/Basic.olean", + "sha256": "265104afaeebfc4163d1f1ab6bc8913ec7def48a6e0cf7c33a619e7c6b7996cd" + }, + "Init.Data.Int.Bitwise.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise/Lemmas.olean", + "sha256": "61fdbf3f93888946c2c76b36a1ac73246abd87048eb30a596d009a0dddfe3af0" + }, + "Init.Data.Int.Cooper": { + "relative_path": "lib/lean/Init/Data/Int/Cooper.olean", + "sha256": "607b77466cb24c6ae2b99b1bd054709dd7e315d0019d87854e45e588d2f4f061" + }, + "Init.Data.Int.DivMod": { + "relative_path": "lib/lean/Init/Data/Int/DivMod.olean", + "sha256": "0ac18881bb522630e818a1f973051dd26d51a7edfe6589132274694575627416" + }, + "Init.Data.Int.DivMod.Basic": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Basic.olean", + "sha256": "1bf5aad5de1a3d6931194060a4fe8fa304dced06404dd2815057179beecb7945" + }, + "Init.Data.Int.DivMod.Bootstrap": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Bootstrap.olean", + "sha256": "9f5e940c4fba88142e73ea864aee5257a1bf31566d3d67d1ebdd60967230d2c5" + }, + "Init.Data.Int.DivMod.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Lemmas.olean", + "sha256": "dbb9ae219e1f2072be3ed6986c5f713b1df79f563fab946fc903c7bcfdce7f48" + }, + "Init.Data.Int.Gcd": { + "relative_path": "lib/lean/Init/Data/Int/Gcd.olean", + "sha256": "294b7f9b1144098337d3b1eae9a286741c2a503388078bd601cf03bbc74e5af8" + }, + "Init.Data.Int.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/Lemmas.olean", + "sha256": "e447675a36f3fa775915d9c711e4172eb1575cb80d4f631ea9b4a0cf7319d791" + }, + "Init.Data.Int.LemmasAux": { + "relative_path": "lib/lean/Init/Data/Int/LemmasAux.olean", + "sha256": "f58eaab4a411b1dd8b2505d7b5479dc203c603ea9ee4a28dfc2e37ac6a1c50d3" + }, + "Init.Data.Int.Linear": { + "relative_path": "lib/lean/Init/Data/Int/Linear.olean", + "sha256": "a6f99acdf60bcb9b582ef87f01c9d53a76e61ea6466a7f4a9d5e4d5c9f564bc8" + }, + "Init.Data.Int.OfNat": { + "relative_path": "lib/lean/Init/Data/Int/OfNat.olean", + "sha256": "8b91634fcd25ef8639461730e11a2e30d7c0f479bd7c86064f1dbb0edf05d47c" + }, + "Init.Data.Int.Order": { + "relative_path": "lib/lean/Init/Data/Int/Order.olean", + "sha256": "32e716ca6845ff6b54befdb1d6fa157e6980471455c22c7c34a5fa1b206c5aaf" + }, + "Init.Data.Int.Pow": { + "relative_path": "lib/lean/Init/Data/Int/Pow.olean", + "sha256": "916584050412a63f5e067a8d86818a2576cd971f241d2bcce80da6ad9d2cebcd" + }, + "Init.Data.List": { + "relative_path": "lib/lean/Init/Data/List.olean", + "sha256": "a0b4ba4434de3cbe61e2009557a6b2c237e7ed24d903486b02efc2460594ebbe" + }, + "Init.Data.List.Attach": { + "relative_path": "lib/lean/Init/Data/List/Attach.olean", + "sha256": "1b460daad56a1203c465d63575d1fd1b0c417c9b22daa53d1239d3e3cf8858e3" + }, + "Init.Data.List.Basic": { + "relative_path": "lib/lean/Init/Data/List/Basic.olean", + "sha256": "45f40cdc05ba064b67aff84c6957f82c4a2e6edd0052fa508cc749e9d35999e1" + }, + "Init.Data.List.BasicAux": { + "relative_path": "lib/lean/Init/Data/List/BasicAux.olean", + "sha256": "210a850a3c6f96fb462b42a67920eed86b41cdfafd32adb39a272d4f66ab09fe" + }, + "Init.Data.List.Control": { + "relative_path": "lib/lean/Init/Data/List/Control.olean", + "sha256": "b082dae0a9caf27e9ebecc9d183598e091016f323b6b1c30942bfe9ac14915b6" + }, + "Init.Data.List.Count": { + "relative_path": "lib/lean/Init/Data/List/Count.olean", + "sha256": "37e1a1a86c77f09c1ae6f13af53e9f0fbc8dd888485e1796b1c0b2813904811a" + }, + "Init.Data.List.Erase": { + "relative_path": "lib/lean/Init/Data/List/Erase.olean", + "sha256": "2ff3cc2f53a947bba4110106d48bd8e6a746fbdbccda3d3168988377f9bf08d6" + }, + "Init.Data.List.FinRange": { + "relative_path": "lib/lean/Init/Data/List/FinRange.olean", + "sha256": "174b84f766bfad55861d5f9bf45051d705e4762491232c25589eda8491aee1fb" + }, + "Init.Data.List.Find": { + "relative_path": "lib/lean/Init/Data/List/Find.olean", + "sha256": "10dabc67b4e589018d889930fc75a663a75d91c7f083095e5892c3e359019d1d" + }, + "Init.Data.List.Impl": { + "relative_path": "lib/lean/Init/Data/List/Impl.olean", + "sha256": "1e62f8c4f057317bb61e73e76f39cbd3b699c7a45c168ab405f7c2cf35c3d2fe" + }, + "Init.Data.List.Lemmas": { + "relative_path": "lib/lean/Init/Data/List/Lemmas.olean", + "sha256": "ebcbcfb4dfc92e4eb9ece72b6c538b4809f96585313aef48cc91ed3e386f2ecc" + }, + "Init.Data.List.Lex": { + "relative_path": "lib/lean/Init/Data/List/Lex.olean", + "sha256": "3b9fb1bdab57ade29c2834da21d90ae802ccf7e58899b17ff487f6483c56ec72" + }, + "Init.Data.List.MapIdx": { + "relative_path": "lib/lean/Init/Data/List/MapIdx.olean", + "sha256": "bd024799a195c348a5937950048fddade6c7cc32ca43abc8e93a0d77c9593f3c" + }, + "Init.Data.List.MinMax": { + "relative_path": "lib/lean/Init/Data/List/MinMax.olean", + "sha256": "1fc6795971ac8f3530113326fb3e351626a4146db9c4772152b2ffe4a3bb81e1" + }, + "Init.Data.List.Monadic": { + "relative_path": "lib/lean/Init/Data/List/Monadic.olean", + "sha256": "82900949d78e7fc5b7c6415194cba03b2526409b350a39f923a78d9911132448" + }, + "Init.Data.List.Nat": { + "relative_path": "lib/lean/Init/Data/List/Nat.olean", + "sha256": "7963464ebb33af6223be0712ffb5bbe47c4587ae5380a61cbc5c6021baf9b422" + }, + "Init.Data.List.Nat.BEq": { + "relative_path": "lib/lean/Init/Data/List/Nat/BEq.olean", + "sha256": "fa52c59704dd8e1822d4b0257d670aedbb2f82017b74303bf358af42d494a450" + }, + "Init.Data.List.Nat.Basic": { + "relative_path": "lib/lean/Init/Data/List/Nat/Basic.olean", + "sha256": "745ae4e831f8597a5165d4dc9abc953c280a450a6547963f109c0fc18cbd6746" + }, + "Init.Data.List.Nat.Count": { + "relative_path": "lib/lean/Init/Data/List/Nat/Count.olean", + "sha256": "73ccebc5a9a303a8a9f2c9137d3fb60c3191b4d74c40370e53dc15e781536493" + }, + "Init.Data.List.Nat.Erase": { + "relative_path": "lib/lean/Init/Data/List/Nat/Erase.olean", + "sha256": "b8d0f4703d71d05efc7c94d8d2c2bad1278f1c65302ce0ee11275e93857f3b3c" + }, + "Init.Data.List.Nat.Find": { + "relative_path": "lib/lean/Init/Data/List/Nat/Find.olean", + "sha256": "73d6e91b894c9907bdb3a7087fa1fcc174fe4a96aac39055a797b84b8ec5f26a" + }, + "Init.Data.List.Nat.InsertIdx": { + "relative_path": "lib/lean/Init/Data/List/Nat/InsertIdx.olean", + "sha256": "5c5ac7ada578ca3a04908c1c6b94e2f12e684da28a3534fd8e2fb1712ba06a38" + }, + "Init.Data.List.Nat.Modify": { + "relative_path": "lib/lean/Init/Data/List/Nat/Modify.olean", + "sha256": "275e5291a6691082786680f93b2e0d09710e0fbcd9640b6503bbbf35041756aa" + }, + "Init.Data.List.Nat.Pairwise": { + "relative_path": "lib/lean/Init/Data/List/Nat/Pairwise.olean", + "sha256": "8aae1be95bb7c08d8e20bde2bdc46d737a4c54c6c132fb093782603e11f88e36" + }, + "Init.Data.List.Nat.Perm": { + "relative_path": "lib/lean/Init/Data/List/Nat/Perm.olean", + "sha256": "d34b546b7057199bf2b89b45908696cdc173bcbb8ff6e14c20e8553fce164014" + }, + "Init.Data.List.Nat.Range": { + "relative_path": "lib/lean/Init/Data/List/Nat/Range.olean", + "sha256": "56804bb0f398b27aba960edeff1d44703f3d59c67c72f540b9e4016fe7e005a3" + }, + "Init.Data.List.Nat.Sublist": { + "relative_path": "lib/lean/Init/Data/List/Nat/Sublist.olean", + "sha256": "cb179f24812905731bee16e0aabbf5eda0d6e1a07d693a0297798e3fab4316ab" + }, + "Init.Data.List.Nat.TakeDrop": { + "relative_path": "lib/lean/Init/Data/List/Nat/TakeDrop.olean", + "sha256": "86594d76cd6bca152ceabb5eaf14e7d2843b484cc2ae20233bf70eca4db3d470" + }, + "Init.Data.List.Notation": { + "relative_path": "lib/lean/Init/Data/List/Notation.olean", + "sha256": "231f63a53a24060f593b32f6321d2e5f1159bdb57172f5fd3e9ca2c38f137733" + }, + "Init.Data.List.OfFn": { + "relative_path": "lib/lean/Init/Data/List/OfFn.olean", + "sha256": "4d4a1feaf8df21b7567908a2723e0cd0bbb9ab1568a9cf1e6536c08a177c1119" + }, + "Init.Data.List.Pairwise": { + "relative_path": "lib/lean/Init/Data/List/Pairwise.olean", + "sha256": "6a00f9b67bb5554815fb9ca404ddf0f7df1fcb0c53d9b40a7de569f752a70779" + }, + "Init.Data.List.Perm": { + "relative_path": "lib/lean/Init/Data/List/Perm.olean", + "sha256": "16c720de1fc7adedfc438ed72845cdc53267779413765172a77e4540662d1a10" + }, + "Init.Data.List.Range": { + "relative_path": "lib/lean/Init/Data/List/Range.olean", + "sha256": "646ca36cfb7cb2359c5589af542f7b1714018cd2c2e06e705f38e8e69515ef29" + }, + "Init.Data.List.Sort": { + "relative_path": "lib/lean/Init/Data/List/Sort.olean", + "sha256": "c2718b7978559839c5c4493fa3a8efec0f89b75ba052319781ff102e2d4f874a" + }, + "Init.Data.List.Sort.Basic": { + "relative_path": "lib/lean/Init/Data/List/Sort/Basic.olean", + "sha256": "2358d6d69b08c0a229dd3fdc38598e300f65e534ac1a3db61495d2c68440b783" + }, + "Init.Data.List.Sort.Impl": { + "relative_path": "lib/lean/Init/Data/List/Sort/Impl.olean", + "sha256": "663f7c421f200455d1b5f73bbb1bc7698a83258cc2b8dd36d537f016f9eb9a77" + }, + "Init.Data.List.Sort.Lemmas": { + "relative_path": "lib/lean/Init/Data/List/Sort/Lemmas.olean", + "sha256": "8c31e71b3777de0363ff903a15fb77da2b64ca6e2a6df7e0f169c6fa6c68b9fc" + }, + "Init.Data.List.Sublist": { + "relative_path": "lib/lean/Init/Data/List/Sublist.olean", + "sha256": "626fc37b3fccd3ad01e524e497bed2e7470f69025ffb5c96477c5dda33cf93b8" + }, + "Init.Data.List.TakeDrop": { + "relative_path": "lib/lean/Init/Data/List/TakeDrop.olean", + "sha256": "6ad55d35f8158e3093612d2bd82b2fcc6e0e2692b89276374fbad91d05316236" + }, + "Init.Data.List.ToArray": { + "relative_path": "lib/lean/Init/Data/List/ToArray.olean", + "sha256": "d48db070507418071d7f3294285e8fd02ded1fe084445b6a728476fa0e5ef34b" + }, + "Init.Data.List.ToArrayImpl": { + "relative_path": "lib/lean/Init/Data/List/ToArrayImpl.olean", + "sha256": "877b70f91eb55124127734da7195914515b98abc3d601053119e4d10b3c749bf" + }, + "Init.Data.List.Zip": { + "relative_path": "lib/lean/Init/Data/List/Zip.olean", + "sha256": "b3ec8eed3d680c246fefdb0e57293acd2c2257a085937f2d1e026d118f6d3979" + }, + "Init.Data.Nat": { + "relative_path": "lib/lean/Init/Data/Nat.olean", + "sha256": "3447a7734bddbbc6904f5135e848dbca25c10bc5b6fad83b1beb09ac5bdb1fae" + }, + "Init.Data.Nat.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Basic.olean", + "sha256": "b2d11a9c4afa558c793fa12d41da087604ee0cf5dd8ee4f3c2f0b08e90031a50" + }, + "Init.Data.Nat.Bitwise": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise.olean", + "sha256": "ec84e12fb7c621de1fe2a6d0cf393bdec0b211e0741b6b343130d09417e0adc9" + }, + "Init.Data.Nat.Bitwise.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise/Basic.olean", + "sha256": "8f01e5e6af6b3366171fb8f21ba8a336c0ddef11a2a180b0fc033ef53757a69a" + }, + "Init.Data.Nat.Bitwise.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise/Lemmas.olean", + "sha256": "844179c496ff2ff5233abfec08e333e04170dd8b49a43f98ae15be7539b83b4b" + }, + "Init.Data.Nat.Compare": { + "relative_path": "lib/lean/Init/Data/Nat/Compare.olean", + "sha256": "9ce920efa06d6fb5e143925d07dd673e488640a5fc56c8c814ef41f383a0b6aa" + }, + "Init.Data.Nat.Control": { + "relative_path": "lib/lean/Init/Data/Nat/Control.olean", + "sha256": "126864791c444a3025fb8be008a42e792773f82535cb1fe9c80b6a9b0cbb0783" + }, + "Init.Data.Nat.Div.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Div/Basic.olean", + "sha256": "90ace86481881951b8aac0c78b829052894c5168bb81b4e32c48daefe634259e" + }, + "Init.Data.Nat.Div.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Div/Lemmas.olean", + "sha256": "06a8a626caa61480fa596adfa0fe6230b4b84cdbbf4f049da8a744dffa25efbc" + }, + "Init.Data.Nat.Dvd": { + "relative_path": "lib/lean/Init/Data/Nat/Dvd.olean", + "sha256": "36f58914fb3acef3f1b99aae4e1024647886c96f3575cd2cdb7b90e48b63a62f" + }, + "Init.Data.Nat.Fold": { + "relative_path": "lib/lean/Init/Data/Nat/Fold.olean", + "sha256": "ccbbc29df5d8b98e47f6d1ee36aa3cb036aa61c3adad7945bd72ef22117ecf0a" + }, + "Init.Data.Nat.Gcd": { + "relative_path": "lib/lean/Init/Data/Nat/Gcd.olean", + "sha256": "746fe45b4e8c648caebc10c1ba9e2736ebd492bb4854edc96c8d5c0f10905666" + }, + "Init.Data.Nat.Lcm": { + "relative_path": "lib/lean/Init/Data/Nat/Lcm.olean", + "sha256": "bbb02321b1e2b2422adf0d8c10b3800afe668a9edbb434e3dbd83c45386539de" + }, + "Init.Data.Nat.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Lemmas.olean", + "sha256": "7acb7e4f1b14d45188f28aa341f9013ee1c6bba8f0e1c2f3be74e04dd24b4782" + }, + "Init.Data.Nat.Linear": { + "relative_path": "lib/lean/Init/Data/Nat/Linear.olean", + "sha256": "33b034e32879e503ae843a62df9969d47e341eddf2650e299209e1494e507c2c" + }, + "Init.Data.Nat.Log2": { + "relative_path": "lib/lean/Init/Data/Nat/Log2.olean", + "sha256": "a1147619414a0561c2e404ca16b6f9c1b3e764fd66917d26964ff53d6f33d10b" + }, + "Init.Data.Nat.MinMax": { + "relative_path": "lib/lean/Init/Data/Nat/MinMax.olean", + "sha256": "813cd65d09f92a707754d8d86d35ae396b2ac77953076e7444021250799546dc" + }, + "Init.Data.Nat.Mod": { + "relative_path": "lib/lean/Init/Data/Nat/Mod.olean", + "sha256": "232fa20934aab58dfc025430ba91fe814d90e0e67f979a401fc91ea8a0fd06e3" + }, + "Init.Data.Nat.Power2": { + "relative_path": "lib/lean/Init/Data/Nat/Power2.olean", + "sha256": "aa68d47f1481ea940e4f2f3eeb5eb0cf44d9d36a81f02609f834bce92b36144a" + }, + "Init.Data.Nat.SOM": { + "relative_path": "lib/lean/Init/Data/Nat/SOM.olean", + "sha256": "be398ccbd96728c1500ab66aa2063131d37d6acd214067dbe14fb3a61150ff4d" + }, + "Init.Data.Nat.Simproc": { + "relative_path": "lib/lean/Init/Data/Nat/Simproc.olean", + "sha256": "491fdb35ea98fc6d352b6cb46c3681d42cb9e23f2df42a07a8e764b54ef7a62b" + }, + "Init.Data.NeZero": { + "relative_path": "lib/lean/Init/Data/NeZero.olean", + "sha256": "5fcec208f2769e4ec00ebf7dc0b534ffba76859d7390bac0ba36da69c8d06d0d" + }, + "Init.Data.OfScientific": { + "relative_path": "lib/lean/Init/Data/OfScientific.olean", + "sha256": "5a86fb094fc122609b959999bc53159282db03b2aba36b1d564270c95b630cc7" + }, + "Init.Data.Option": { + "relative_path": "lib/lean/Init/Data/Option.olean", + "sha256": "7cec7ba7cbb4f8c12b723822ef37fa80d7fe6dad55ffe781b04d480f37bee3e9" + }, + "Init.Data.Option.Attach": { + "relative_path": "lib/lean/Init/Data/Option/Attach.olean", + "sha256": "d13d8661e92455466e2652e81b0fc20660c6f68f61563e06ff9ada3b2adef85e" + }, + "Init.Data.Option.Basic": { + "relative_path": "lib/lean/Init/Data/Option/Basic.olean", + "sha256": "8a83ae7602811f2a8caa2f5ec890dfcaad71b7fee193f45329f23ce538838eae" + }, + "Init.Data.Option.BasicAux": { + "relative_path": "lib/lean/Init/Data/Option/BasicAux.olean", + "sha256": "69c9769a227956d0a18263f65759b2c78eeca5fc23df52fada29fae941be58b8" + }, + "Init.Data.Option.Instances": { + "relative_path": "lib/lean/Init/Data/Option/Instances.olean", + "sha256": "c2af58842fc1a5ace3156d8cc201a287eb79ad7707be50f11d43d9f6096452b8" + }, + "Init.Data.Option.Lemmas": { + "relative_path": "lib/lean/Init/Data/Option/Lemmas.olean", + "sha256": "832a8d1633685e7ace5ceb52ee44b1f441548ff85b6f15687314cc3709b9138e" + }, + "Init.Data.Option.List": { + "relative_path": "lib/lean/Init/Data/Option/List.olean", + "sha256": "919cbd303c6345f52d6c019146d46b4249daf12fe9fd3c2cfbece14797be8393" + }, + "Init.Data.Option.Monadic": { + "relative_path": "lib/lean/Init/Data/Option/Monadic.olean", + "sha256": "6f76327d567c5dbf041689c11ff396fdebbc832a1640d003ad2020671282aeb1" + }, + "Init.Data.Ord": { + "relative_path": "lib/lean/Init/Data/Ord.olean", + "sha256": "f9c47b462803dd4e251e3c89acc944998c255728461d0b038aa239e067c81a9c" + }, + "Init.Data.PLift": { + "relative_path": "lib/lean/Init/Data/PLift.olean", + "sha256": "2bed69175449aa3166dc103d9cf368e494b4d1752ed6e864250214256d710739" + }, + "Init.Data.Prod": { + "relative_path": "lib/lean/Init/Data/Prod.olean", + "sha256": "0498bf822d3922cd5bbc154bf0adef4fd76e4fe6a57f8e39fefa49ae9e16ca13" + }, + "Init.Data.Queue": { + "relative_path": "lib/lean/Init/Data/Queue.olean", + "sha256": "ab5118c07c9c0ed7d0819d19d442d1e6143f265f784f48151be1c4e2cd895606" + }, + "Init.Data.RArray": { + "relative_path": "lib/lean/Init/Data/RArray.olean", + "sha256": "9abe7370b3817a85b8512bc51dadc386f314bdcec188736b2f87405d5a9bb09b" + }, + "Init.Data.Random": { + "relative_path": "lib/lean/Init/Data/Random.olean", + "sha256": "5a34ed96d6a9814781db7e6c93847b8cd7caeb7071b2256058964866ec706af5" + }, + "Init.Data.Range": { + "relative_path": "lib/lean/Init/Data/Range.olean", + "sha256": "c64640dc9f5f61844778a90d7acc0f8f632ec11aa1746689c960d0f459bfaf46" + }, + "Init.Data.Range.Basic": { + "relative_path": "lib/lean/Init/Data/Range/Basic.olean", + "sha256": "bf692fd52dbffb6518f9a189179263fc4c49b436dbdb9eba2f00940de6665353" + }, + "Init.Data.Range.Lemmas": { + "relative_path": "lib/lean/Init/Data/Range/Lemmas.olean", + "sha256": "19e241eb048d7046e42e9117499d5bc8a43dddf66dacbb087966b4d16b82b06b" + }, + "Init.Data.Repr": { + "relative_path": "lib/lean/Init/Data/Repr.olean", + "sha256": "cbbd2014d6cee442d42c9c4d6997aa1e27dd3a4ea4fef43d1de4c1f184d02138" + }, + "Init.Data.SInt": { + "relative_path": "lib/lean/Init/Data/SInt.olean", + "sha256": "21f02e1e015c8ceee0e8afe9a24f8150714739a4df724b922e7b3f3756cc530d" + }, + "Init.Data.SInt.Basic": { + "relative_path": "lib/lean/Init/Data/SInt/Basic.olean", + "sha256": "c4b9b22f462ffe3dac0f5ce0d810e9cbbd3dda83a3c8f61aaca350f99edf30d9" + }, + "Init.Data.SInt.Bitwise": { + "relative_path": "lib/lean/Init/Data/SInt/Bitwise.olean", + "sha256": "784166152e7e37d32e49f556007eb9e8ac78a11e25a33159256124b1b6ac78b9" + }, + "Init.Data.SInt.Float": { + "relative_path": "lib/lean/Init/Data/SInt/Float.olean", + "sha256": "0fa2df58fc374f7d8f8381dc7369e0359fd56854418863015d82b50a49032bdd" + }, + "Init.Data.SInt.Float32": { + "relative_path": "lib/lean/Init/Data/SInt/Float32.olean", + "sha256": "08b0e06d73a8cc4989ef19e5b5dc0255aa458e852dade1660aeee88046199fb6" + }, + "Init.Data.SInt.Lemmas": { + "relative_path": "lib/lean/Init/Data/SInt/Lemmas.olean", + "sha256": "14f5714b32a97f7b89fe4f737e96d2d9576a75fdbdf62b848c26140b1be0d0b9" + }, + "Init.Data.Stream": { + "relative_path": "lib/lean/Init/Data/Stream.olean", + "sha256": "df7b2b39a4577fbe33f63d916ef4e0592fea0db8bc542b7e3f65bf8fca137950" + }, + "Init.Data.String": { + "relative_path": "lib/lean/Init/Data/String.olean", + "sha256": "44d46641afe72049132e8ba521b7e404190fb50b1710a008a531a6cb4bce4308" + }, + "Init.Data.String.Basic": { + "relative_path": "lib/lean/Init/Data/String/Basic.olean", + "sha256": "d7404ec9c0cedeb3e77cc7eadc3201e7cf1d44e1029407a279ce5dd2ab5537d1" + }, + "Init.Data.String.Extra": { + "relative_path": "lib/lean/Init/Data/String/Extra.olean", + "sha256": "5291234dedeae61b8f31129e9e8d90fcc2b91a784384250d36eea11c694e359a" + }, + "Init.Data.String.Lemmas": { + "relative_path": "lib/lean/Init/Data/String/Lemmas.olean", + "sha256": "e2fa260513d3ccaba3d0547bc5625ebbe09a171762e375b38b6dc1b8dc0fa6f5" + }, + "Init.Data.Subtype": { + "relative_path": "lib/lean/Init/Data/Subtype.olean", + "sha256": "1278a669b084dabde55a3f9a14c8b3ea7b7753b4b4d52bdbc1066bcb29f30208" + }, + "Init.Data.Sum": { + "relative_path": "lib/lean/Init/Data/Sum.olean", + "sha256": "0c08e5312a75c9474abf94ce7f6358efbdc6c178476005e36c22b5b294647930" + }, + "Init.Data.Sum.Basic": { + "relative_path": "lib/lean/Init/Data/Sum/Basic.olean", + "sha256": "30b5a85e6941f567feb412f1e6a4382d5c6d52558c4657285e80bd1b58879427" + }, + "Init.Data.Sum.Lemmas": { + "relative_path": "lib/lean/Init/Data/Sum/Lemmas.olean", + "sha256": "01ce321477e3f24f07aca5b0c4423c46d4c4e9533f25e00cdfd3f7e0af9ba319" + }, + "Init.Data.ToString": { + "relative_path": "lib/lean/Init/Data/ToString.olean", + "sha256": "bf141c2b4f750f8154aff447a05b8c02fc0231c48e550bf29823dd3a101b60a6" + }, + "Init.Data.ToString.Basic": { + "relative_path": "lib/lean/Init/Data/ToString/Basic.olean", + "sha256": "0892126af7fd71f9dd48a1f051af4f1ca5f181389a9b97dd7c759abcb8088fd0" + }, + "Init.Data.ToString.Macro": { + "relative_path": "lib/lean/Init/Data/ToString/Macro.olean", + "sha256": "3284b8ed0d3883ba46d39abb4d3620820bf6f12e47bfe3f33ead82ad80039580" + }, + "Init.Data.UInt": { + "relative_path": "lib/lean/Init/Data/UInt.olean", + "sha256": "a92781a10cb664f3b9dc344957d3c5c95bf9ec44fbe192cbb6ceac4c1d9f1391" + }, + "Init.Data.UInt.Basic": { + "relative_path": "lib/lean/Init/Data/UInt/Basic.olean", + "sha256": "d30c2c0bff573487362546d06fe7cf8fc0ae6dfead1379a1ad2523fc96795eb9" + }, + "Init.Data.UInt.BasicAux": { + "relative_path": "lib/lean/Init/Data/UInt/BasicAux.olean", + "sha256": "76e27df77fe31ef1d6b54d00a1758d579532a15787f4cfec7da774d535b47072" + }, + "Init.Data.UInt.Bitwise": { + "relative_path": "lib/lean/Init/Data/UInt/Bitwise.olean", + "sha256": "aa829cd7c8a6e68d0365d1662727646fc68b817428e469b33d96d057f6643d4e" + }, + "Init.Data.UInt.Lemmas": { + "relative_path": "lib/lean/Init/Data/UInt/Lemmas.olean", + "sha256": "5912f89a17ba6b111d9d7f3df46904b90811a4cdd80fc02a06984cd4c3dd3aa0" + }, + "Init.Data.UInt.Log2": { + "relative_path": "lib/lean/Init/Data/UInt/Log2.olean", + "sha256": "315c374ceeecdab0fde8042abffb68b082f063ce3ebf810efa46d89eb239faca" + }, + "Init.Data.ULift": { + "relative_path": "lib/lean/Init/Data/ULift.olean", + "sha256": "e1187f01e60437dc3c741cd1ba76657855642cc2574a59fa9a3be9a9e9d435b4" + }, + "Init.Data.Vector": { + "relative_path": "lib/lean/Init/Data/Vector.olean", + "sha256": "8ff79e5ffafceccc1bc38f3ac3d5ae7eb802c95cf1bd51393c6af7be6dfdea63" + }, + "Init.Data.Vector.Attach": { + "relative_path": "lib/lean/Init/Data/Vector/Attach.olean", + "sha256": "ecf089f945d2adcc57180f779593ccf0a2fa0c27d89968a7722b914f4b58b8af" + }, + "Init.Data.Vector.Basic": { + "relative_path": "lib/lean/Init/Data/Vector/Basic.olean", + "sha256": "afacc92812490337d7f03950905748563477bfe6494f046a0dfd9451aa4a4d65" + }, + "Init.Data.Vector.Count": { + "relative_path": "lib/lean/Init/Data/Vector/Count.olean", + "sha256": "b23fa70c6a9f0ea3b8ed1a4c811a2d0557751d4bb798e954d1ff985e00d492b1" + }, + "Init.Data.Vector.DecidableEq": { + "relative_path": "lib/lean/Init/Data/Vector/DecidableEq.olean", + "sha256": "4cf94f33d63c842c39f35392ce1bbf4c40ed1bfe9ec5161d522ba1442d8e0a2c" + }, + "Init.Data.Vector.Erase": { + "relative_path": "lib/lean/Init/Data/Vector/Erase.olean", + "sha256": "8c5cf30ba1225d74d85f93b3553f09e9299c182805f0efb44fad509ea5e56b78" + }, + "Init.Data.Vector.Extract": { + "relative_path": "lib/lean/Init/Data/Vector/Extract.olean", + "sha256": "0e12201859d76ac91415a74e00f909b32a631fefd2d2b5d7afeb0d2730bfa47a" + }, + "Init.Data.Vector.FinRange": { + "relative_path": "lib/lean/Init/Data/Vector/FinRange.olean", + "sha256": "b862166a52500e392a3cfab1b4b4f5d2b7b202725f48526a1e935ca52abdda38" + }, + "Init.Data.Vector.InsertIdx": { + "relative_path": "lib/lean/Init/Data/Vector/InsertIdx.olean", + "sha256": "c3f496caa69211325d18bc909f9be134bfd07515f8b95773b252004a71e01fc5" + }, + "Init.Data.Vector.Lemmas": { + "relative_path": "lib/lean/Init/Data/Vector/Lemmas.olean", + "sha256": "35726f2c825e29355e25d574a25470dba908ea9f680b92f4e6ab57ec77d47f3d" + }, + "Init.Data.Vector.Lex": { + "relative_path": "lib/lean/Init/Data/Vector/Lex.olean", + "sha256": "1541eb5302ac1fe618815bd36a3d4468f08003a6571118fc8322bbf155b441de" + }, + "Init.Data.Vector.MapIdx": { + "relative_path": "lib/lean/Init/Data/Vector/MapIdx.olean", + "sha256": "cbe812bbd7839fae0178d0c183d96d1f29f768b55349bebb47628f903c7cda57" + }, + "Init.Data.Vector.Monadic": { + "relative_path": "lib/lean/Init/Data/Vector/Monadic.olean", + "sha256": "c44bb39a17f785673f64d6e40116173d821d9184c41377371c5cb73565440a30" + }, + "Init.Data.Vector.OfFn": { + "relative_path": "lib/lean/Init/Data/Vector/OfFn.olean", + "sha256": "69f88342bdd241ebafeffb51ee94c1363ab096ea6d435ef4d062b1a552167cf4" + }, + "Init.Data.Vector.Range": { + "relative_path": "lib/lean/Init/Data/Vector/Range.olean", + "sha256": "88351024a2b10fd4648a0ae15e005d8799b95be7d0060c89a5a205a4fc40b56f" + }, + "Init.Data.Vector.Zip": { + "relative_path": "lib/lean/Init/Data/Vector/Zip.olean", + "sha256": "8c28067d8d5289ec3a5cbc9674643c688210c75813c69c0b66baba5ea29abaea" + }, + "Init.Data.Zero": { + "relative_path": "lib/lean/Init/Data/Zero.olean", + "sha256": "04d070309e7a1962ebcb5de2b2bfa69e5f5d4d54477689cbdbadb21202611dac" + }, + "Init.Dynamic": { + "relative_path": "lib/lean/Init/Dynamic.olean", + "sha256": "a9982d28dff48820a4e5310d473b53d19de91c1d1685749bccb849e881219fa1" + }, + "Init.Ext": { + "relative_path": "lib/lean/Init/Ext.olean", + "sha256": "1f32591106d111c224423e61d0afd89014b96aa77e9141c6bec47b33b80c31f7" + }, + "Init.GetElem": { + "relative_path": "lib/lean/Init/GetElem.olean", + "sha256": "2683b27cced90b5fbfbe5213c309ed94bf423edf90924a1002eea72b152fdb58" + }, + "Init.Grind": { + "relative_path": "lib/lean/Init/Grind.olean", + "sha256": "33eff60d5cea8bd5db12879a12cf1a1cf772b1a2ab778136cc138685bc23654a" + }, + "Init.Grind.Cases": { + "relative_path": "lib/lean/Init/Grind/Cases.olean", + "sha256": "d086d84578922287a95fedee2f43e884a629e838c2ff8e71efc2910510509594" + }, + "Init.Grind.Lemmas": { + "relative_path": "lib/lean/Init/Grind/Lemmas.olean", + "sha256": "ca22a5c6a54190290fc558e7805244c66c3c044c3a708a98300703d70bef11ec" + }, + "Init.Grind.Norm": { + "relative_path": "lib/lean/Init/Grind/Norm.olean", + "sha256": "3f889971f8415ffff0f737c2214d5be92be1294398624aec1c9d9bd45942dd66" + }, + "Init.Grind.Offset": { + "relative_path": "lib/lean/Init/Grind/Offset.olean", + "sha256": "4f95e7282b636fe3690d8b159425a37bf5bb2f80c49e7ccdd6170b6977148d50" + }, + "Init.Grind.PP": { + "relative_path": "lib/lean/Init/Grind/PP.olean", + "sha256": "d94c99691443ce7517096899dc89ffd3a1eff62b621e530ff98e46ff7a9e4407" + }, + "Init.Grind.Propagator": { + "relative_path": "lib/lean/Init/Grind/Propagator.olean", + "sha256": "e292ef4b9a9a4475f7c6eb767ddc84d8b5f0a30feabbbb1664966930e050496f" + }, + "Init.Grind.Tactics": { + "relative_path": "lib/lean/Init/Grind/Tactics.olean", + "sha256": "8c21109288355c0969f3fae78c66756b2a73699d4170d53336d0825a82b2b82d" + }, + "Init.Grind.Util": { + "relative_path": "lib/lean/Init/Grind/Util.olean", + "sha256": "666cf848a9a3ba30885be219a767d96bd2b6582fde19f84110c3c583308c5e8f" + }, + "Init.Guard": { + "relative_path": "lib/lean/Init/Guard.olean", + "sha256": "3bec2e0ab8c2829d1d13c64c80fb983b5d5f115a67b29ee64eedbe3f6628a470" + }, + "Init.Hints": { + "relative_path": "lib/lean/Init/Hints.olean", + "sha256": "5c814650ff2f23259cc67c04ab1a438222ec084d4369aca679fd0cc07cbb5474" + }, + "Init.Internal": { + "relative_path": "lib/lean/Init/Internal.olean", + "sha256": "2927550a155fb6115ac63e31cc35f9969047a6c015ced8325ce769d5631c0200" + }, + "Init.Internal.Order": { + "relative_path": "lib/lean/Init/Internal/Order.olean", + "sha256": "37884830614f3f48f325497beadc3cc60f0e363a1846cdcc28221ca05ba39759" + }, + "Init.Internal.Order.Basic": { + "relative_path": "lib/lean/Init/Internal/Order/Basic.olean", + "sha256": "c0b362116c8f553cc59964154fdc9a3418672bf9b5caee2b745608f40aa71091" + }, + "Init.Internal.Order.Lemmas": { + "relative_path": "lib/lean/Init/Internal/Order/Lemmas.olean", + "sha256": "198fb9d38168f2116937d641fa5419c99e0e9c03c0f630756f68affca451c1e0" + }, + "Init.Internal.Order.Tactic": { + "relative_path": "lib/lean/Init/Internal/Order/Tactic.olean", + "sha256": "d519c1d64b866e639de30ef452587bbe8802c64536e6ee541e47fcc7be3f942d" + }, + "Init.MacroTrace": { + "relative_path": "lib/lean/Init/MacroTrace.olean", + "sha256": "49d356d5728ea1a0ed6a14cbca10b6387f99d40b85602189566c4e4c1d6cc524" + }, + "Init.Meta": { + "relative_path": "lib/lean/Init/Meta.olean", + "sha256": "16b7ad338addb717e0eb584fc583a2e9d4e08242040654a2d3546650cb71bddc" + }, + "Init.MetaTypes": { + "relative_path": "lib/lean/Init/MetaTypes.olean", + "sha256": "1aa89a88743c9d8f66daecc6f28a7a7816efad55a42129bca1e2220450747bd8" + }, + "Init.Notation": { + "relative_path": "lib/lean/Init/Notation.olean", + "sha256": "576706b70dc9f21b093c7b10755e25c2f3fea8f04586b128893308730d715dae" + }, + "Init.NotationExtra": { + "relative_path": "lib/lean/Init/NotationExtra.olean", + "sha256": "92ba272c0a25c97e7800cdf2e948bb20e374861d28d31736d80a757b7dd852b0" + }, + "Init.Omega": { + "relative_path": "lib/lean/Init/Omega.olean", + "sha256": "ef46ae7141263a8f3168ddc0de5b10c37cd991f907e6558d6a10daed027950ad" + }, + "Init.Omega.Coeffs": { + "relative_path": "lib/lean/Init/Omega/Coeffs.olean", + "sha256": "a7f2688fb1799c93744fb62301026c37c58ee81d58eb91e80041622397bd1dd3" + }, + "Init.Omega.Constraint": { + "relative_path": "lib/lean/Init/Omega/Constraint.olean", + "sha256": "1e5a89907d661084e3223c006975f275efbe03df7c43fd18a68425798ac09189" + }, + "Init.Omega.Int": { + "relative_path": "lib/lean/Init/Omega/Int.olean", + "sha256": "335df595a7449bc9ab310b9a5914bcae3ad6219121cd1f67261deb8383b5d61d" + }, + "Init.Omega.IntList": { + "relative_path": "lib/lean/Init/Omega/IntList.olean", + "sha256": "315f3755c1bdb87eda3449e97cb3141b9bc69b88af3faa93b0c54a5bf16137bf" + }, + "Init.Omega.LinearCombo": { + "relative_path": "lib/lean/Init/Omega/LinearCombo.olean", + "sha256": "6f254b2ed1ea5d35519b633f58da229500dca18293b3d958c7f93cc6a7e64e67" + }, + "Init.Omega.Logic": { + "relative_path": "lib/lean/Init/Omega/Logic.olean", + "sha256": "c8b7e60bd2aeee6efbab4f4787a5eddcb8b6ccb02841b7948b5120b5dbc7f5be" + }, + "Init.Prelude": { + "relative_path": "lib/lean/Init/Prelude.olean", + "sha256": "db4e87c0006f1303f3d41ca9a615a4890ca94309812bda09476677ea9bb5d672" + }, + "Init.PropLemmas": { + "relative_path": "lib/lean/Init/PropLemmas.olean", + "sha256": "f95cab4646f43dbaca3fc915bbd32868f0ac73aaeba818d165843e276499542e" + }, + "Init.RCases": { + "relative_path": "lib/lean/Init/RCases.olean", + "sha256": "aa216281d8930fe16cdb7b6b1f604066e824b33eaf62870d41391040c2ba77b4" + }, + "Init.ShareCommon": { + "relative_path": "lib/lean/Init/ShareCommon.olean", + "sha256": "c2647e2778a9bf01ffdc302ea5604308036ee982de23feac85ce21805f0b3ba8" + }, + "Init.SimpLemmas": { + "relative_path": "lib/lean/Init/SimpLemmas.olean", + "sha256": "37b58f69317f08a8e55d1f3950c4d00ccb29ebed135eb5e9789e8feb4f412369" + }, + "Init.Simproc": { + "relative_path": "lib/lean/Init/Simproc.olean", + "sha256": "53b36872b429c61141ac340011f233e680f82ccced2fb43fabf9fbeca5807040" + }, + "Init.SizeOf": { + "relative_path": "lib/lean/Init/SizeOf.olean", + "sha256": "0b2e2a18d9b699a5236c79acca835fd68f5400bbd998ca5743825c5734b6d589" + }, + "Init.SizeOfLemmas": { + "relative_path": "lib/lean/Init/SizeOfLemmas.olean", + "sha256": "ef5ba22b92506575f987eaea9cb87eda5a1d870da071e53f1257cb1cc999fd85" + }, + "Init.Syntax": { + "relative_path": "lib/lean/Init/Syntax.olean", + "sha256": "55eab3582563a12c40c7797ed6d06db613c855508c3138df975d2613422f6399" + }, + "Init.System": { + "relative_path": "lib/lean/Init/System.olean", + "sha256": "7a0e2f92d28211ac4da2835c7b15db71b08799d68e0c759c0f899b7c19ef564c" + }, + "Init.System.FilePath": { + "relative_path": "lib/lean/Init/System/FilePath.olean", + "sha256": "cdc4f4ecf0cd8470047e8c1e706d22f7321bee3072e44a669481e56689e187f1" + }, + "Init.System.IO": { + "relative_path": "lib/lean/Init/System/IO.olean", + "sha256": "069217c5d17f79433867ec6f701a5702cb40c88485dedc61be1f1ce0ef9b44fb" + }, + "Init.System.IOError": { + "relative_path": "lib/lean/Init/System/IOError.olean", + "sha256": "6e1ff344b12e6d7fcbb7abea99eaa3c88ae2626dd669d7f3c545822f96494ec2" + }, + "Init.System.Mutex": { + "relative_path": "lib/lean/Init/System/Mutex.olean", + "sha256": "fc950b4b00a1c3104ea945a9a93ab51807521b29a0b83518127de77eb3f76922" + }, + "Init.System.Platform": { + "relative_path": "lib/lean/Init/System/Platform.olean", + "sha256": "b679564c6df441632b6277f089cd588220ae5c4b8ae519873dc3172bb3091e52" + }, + "Init.System.Promise": { + "relative_path": "lib/lean/Init/System/Promise.olean", + "sha256": "78dc6c800d0f873e6520dbcf32c9dda22370563c75f086fb03e25fae393e848c" + }, + "Init.System.ST": { + "relative_path": "lib/lean/Init/System/ST.olean", + "sha256": "3fc620f17a5cb9e2243d760ffcb7ede9227b8c639c9376ff25c6bea1a7c1a7e7" + }, + "Init.System.Uri": { + "relative_path": "lib/lean/Init/System/Uri.olean", + "sha256": "d1a020ceeb21e6358fb0768345f90866752ef2dfe6c9dec71f388bd34b919de3" + }, + "Init.Tactics": { + "relative_path": "lib/lean/Init/Tactics.olean", + "sha256": "285e86e84ef77045b1f4944cacef6f11bca49334671808adec30f2e6fafd0dd8" + }, + "Init.TacticsExtra": { + "relative_path": "lib/lean/Init/TacticsExtra.olean", + "sha256": "e0521889dab4e1a74e8a407a0a0409109723ab9363b4be234115dc80aa01b5ba" + }, + "Init.Task": { + "relative_path": "lib/lean/Init/Task.olean", + "sha256": "effc51f55f006a6e54f0bb4b6577f7fe6a92d79958a0f3dfd258e4c53b9fa3c8" + }, + "Init.Try": { + "relative_path": "lib/lean/Init/Try.olean", + "sha256": "d289104c53a554fd4e7d8b81d5fd8212dcca854e6dec5cf80e088e3545a23c6b" + }, + "Init.Util": { + "relative_path": "lib/lean/Init/Util.olean", + "sha256": "da825c487c1ff3bf957f8ef84fade6ca10e2428807f84f52613551e11a404f03" + }, + "Init.WF": { + "relative_path": "lib/lean/Init/WF.olean", + "sha256": "16d58f1a3442679940e0f5d0eb9fd209e6eae04f7f4550dd7361847f0ba97082" + }, + "Init.WFTactics": { + "relative_path": "lib/lean/Init/WFTactics.olean", + "sha256": "edeb5134b3fc1f3234ef027a4d803b733c75a7174ac2a4bfe8a6353f783deb32" + }, + "Init.While": { + "relative_path": "lib/lean/Init/While.olean", + "sha256": "6fc8fbe7c581376a6826126ce6aacb031231cdc32afb135dfa3bfda884305625" + }, + "Lean": { + "relative_path": "lib/lean/Lean.olean", + "sha256": "7b09317fc9d21262dbfbb6f014dc40c2809b55e6cbb4f7587211a57ec91f7221" + }, + "Lean.AddDecl": { + "relative_path": "lib/lean/Lean/AddDecl.olean", + "sha256": "ec30e087524b32520021eeb3dc8c2d0aefdce838f11dd8e57f13cf1f05611cf8" + }, + "Lean.Attributes": { + "relative_path": "lib/lean/Lean/Attributes.olean", + "sha256": "e4db4a704b0260d6e36f4f542416091124e09767dc8bc759d2b1adbe53e9c166" + }, + "Lean.AuxRecursor": { + "relative_path": "lib/lean/Lean/AuxRecursor.olean", + "sha256": "8ad6ecf040763b62561819bb75de71763765566d01e68d3ed60fe27ff1b70b92" + }, + "Lean.BuiltinDocAttr": { + "relative_path": "lib/lean/Lean/BuiltinDocAttr.olean", + "sha256": "c9fb01241ff340cc8cdba6efffa553449f24748d42f0966903ce7b3038a6f266" + }, + "Lean.Class": { + "relative_path": "lib/lean/Lean/Class.olean", + "sha256": "0a41587a7d43178adb832ac6a835a3ded745f5b94f031b8a7fa916a6de2d681c" + }, + "Lean.Compiler": { + "relative_path": "lib/lean/Lean/Compiler.olean", + "sha256": "60a1e6cb63d9ee93f449d816b9d5f35d550da07c2ed98d4574cc00610aaa1fcc" + }, + "Lean.Compiler.AtMostOnce": { + "relative_path": "lib/lean/Lean/Compiler/AtMostOnce.olean", + "sha256": "46d86c6dc85f433a42dfa3a3162ed82530e0efd6d0def6857c447342776280b5" + }, + "Lean.Compiler.BorrowedAnnotation": { + "relative_path": "lib/lean/Lean/Compiler/BorrowedAnnotation.olean", + "sha256": "dfd99a6b65e28ce3c81d6effb32273e088fcce5829cbaeec57a98a4f325c70a8" + }, + "Lean.Compiler.CSimpAttr": { + "relative_path": "lib/lean/Lean/Compiler/CSimpAttr.olean", + "sha256": "4228ef18768f8fd70d1c48c5a5e9c7e0736e84389e0cc291d45ea6ef55853c85" + }, + "Lean.Compiler.ClosedTermCache": { + "relative_path": "lib/lean/Lean/Compiler/ClosedTermCache.olean", + "sha256": "332d9fcc102a8ec05d9d450f835de662c8b153274e86f4e8f8bf72bb7c0c86fa" + }, + "Lean.Compiler.ConstFolding": { + "relative_path": "lib/lean/Lean/Compiler/ConstFolding.olean", + "sha256": "a0f0396a65891075ef27848bf3578a2b14c5d9fa295ee982014d97cae25ec46c" + }, + "Lean.Compiler.ExportAttr": { + "relative_path": "lib/lean/Lean/Compiler/ExportAttr.olean", + "sha256": "f0975b5550d69d83ad3b27d0ad2363641167e47178788f22890be83d3e5511e6" + }, + "Lean.Compiler.ExternAttr": { + "relative_path": "lib/lean/Lean/Compiler/ExternAttr.olean", + "sha256": "c015f64d0e192ec7b6774ea02f82e8d210aa29022cc9317ba1f44f4d1db03983" + }, + "Lean.Compiler.FFI": { + "relative_path": "lib/lean/Lean/Compiler/FFI.olean", + "sha256": "5c592270389ca3547b225d542569d17074a72aab1d3069972aa13183c9defb4b" + }, + "Lean.Compiler.IR": { + "relative_path": "lib/lean/Lean/Compiler/IR.olean", + "sha256": "c0d443734bf92a204df7d44fb5b213073d860465d1940beb4f56be04fe95fa5d" + }, + "Lean.Compiler.IR.Basic": { + "relative_path": "lib/lean/Lean/Compiler/IR/Basic.olean", + "sha256": "256c663d51575e663739cf47717d5b563d91bccd233443d8c71ff95eb81ccf2b" + }, + "Lean.Compiler.IR.Borrow": { + "relative_path": "lib/lean/Lean/Compiler/IR/Borrow.olean", + "sha256": "76ccf72d60d34df08de11583942e4978c88f79daea6c48a34aee9b0b0164a143" + }, + "Lean.Compiler.IR.Boxing": { + "relative_path": "lib/lean/Lean/Compiler/IR/Boxing.olean", + "sha256": "ba56d60339b940f7b1d5f1bc244145dd90c835bd7a7c22501af7ab4eb502c7e9" + }, + "Lean.Compiler.IR.Checker": { + "relative_path": "lib/lean/Lean/Compiler/IR/Checker.olean", + "sha256": "0760b0f827e3f94462f855b0cde1e99a4f2ececa4dc914bb36ccc7388d05ea1f" + }, + "Lean.Compiler.IR.CompilerM": { + "relative_path": "lib/lean/Lean/Compiler/IR/CompilerM.olean", + "sha256": "3c51c9bc8b5684d2b997424a46ecfffd0faebaeccc20871faa6142bbdee6261e" + }, + "Lean.Compiler.IR.CtorLayout": { + "relative_path": "lib/lean/Lean/Compiler/IR/CtorLayout.olean", + "sha256": "41b6538779aec55878034a4311f5ec5afb609ee355306207f63d480beec7d8f1" + }, + "Lean.Compiler.IR.ElimDeadBranches": { + "relative_path": "lib/lean/Lean/Compiler/IR/ElimDeadBranches.olean", + "sha256": "db8b2361ec98aeab4251a3f24b6bdd6dfea6560736a7e2db580ac80ea5a19088" + }, + "Lean.Compiler.IR.ElimDeadVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/ElimDeadVars.olean", + "sha256": "fa545c9536767b2921812ec4f12787dbafdb12fba219c37c50ef08406aed35c0" + }, + "Lean.Compiler.IR.EmitC": { + "relative_path": "lib/lean/Lean/Compiler/IR/EmitC.olean", + "sha256": "8d3cc7f7314b0540efc952a891d2c04b146a0e974c78698f257aa84218e22fa8" + }, + "Lean.Compiler.IR.EmitUtil": { + "relative_path": "lib/lean/Lean/Compiler/IR/EmitUtil.olean", + "sha256": "d94b654927d21d70638e7be9f071d042f1ddef03ffb35c8e1873ce06f6bc0bec" + }, + "Lean.Compiler.IR.ExpandResetReuse": { + "relative_path": "lib/lean/Lean/Compiler/IR/ExpandResetReuse.olean", + "sha256": "52056b452d80b3cc358d961c340c878bd8fd439c4157f19579ab24b6e45beb63" + }, + "Lean.Compiler.IR.Format": { + "relative_path": "lib/lean/Lean/Compiler/IR/Format.olean", + "sha256": "7ce035303406e57cca579f9730815aae11392a6b068ebfb1ae5563989ef9d648" + }, + "Lean.Compiler.IR.FreeVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/FreeVars.olean", + "sha256": "b7689c40b2b8acb573130f0678e945f7de1f93cc0d2cc516992b735d3b16600c" + }, + "Lean.Compiler.IR.LiveVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/LiveVars.olean", + "sha256": "04dffa3befd0baf2b1caabada126812e8799e0842e88ae55d2f9f435b210bba7" + }, + "Lean.Compiler.IR.NormIds": { + "relative_path": "lib/lean/Lean/Compiler/IR/NormIds.olean", + "sha256": "42d1c0c091dd6795dc22f817e1bbd69f8a023744028d476ee73c3d47b9094507" + }, + "Lean.Compiler.IR.PushProj": { + "relative_path": "lib/lean/Lean/Compiler/IR/PushProj.olean", + "sha256": "45d3a0ef752e7ec5a2868af25c01793a0e9763307b35d8821fb1aeeb0886e5e7" + }, + "Lean.Compiler.IR.RC": { + "relative_path": "lib/lean/Lean/Compiler/IR/RC.olean", + "sha256": "efe9f4218bc3bc9ff1df43dbd6d5d5629c6914bc69834a1642f67aa16b9c7a1c" + }, + "Lean.Compiler.IR.ResetReuse": { + "relative_path": "lib/lean/Lean/Compiler/IR/ResetReuse.olean", + "sha256": "efe1a6814901274604fe1e6ada5e6819c56a50ade0732c255a5fabbac86b90f0" + }, + "Lean.Compiler.IR.SimpCase": { + "relative_path": "lib/lean/Lean/Compiler/IR/SimpCase.olean", + "sha256": "3c29f2a2fc5a04a44b6afa8c945055dc63aaee07fa17412c49f32b66b93af17b" + }, + "Lean.Compiler.IR.Sorry": { + "relative_path": "lib/lean/Lean/Compiler/IR/Sorry.olean", + "sha256": "4f931aed57566e1db5097e0703d072434871fcfad52bedd7afefda28c9e28b49" + }, + "Lean.Compiler.IR.UnboxResult": { + "relative_path": "lib/lean/Lean/Compiler/IR/UnboxResult.olean", + "sha256": "7a27c69a4b077ee78cd5c060dab56b7af05e02428073627d28ccdff330e74670" + }, + "Lean.Compiler.ImplementedByAttr": { + "relative_path": "lib/lean/Lean/Compiler/ImplementedByAttr.olean", + "sha256": "0bdd1c11d87a3e766eb8372e72dbdc72606b0367551455d1ff3093d50a14ba0e" + }, + "Lean.Compiler.InitAttr": { + "relative_path": "lib/lean/Lean/Compiler/InitAttr.olean", + "sha256": "a4b773a972dd41b77fa8973f7c570e3c2f1eef2a56e36c6b5b91a9543fe23efd" + }, + "Lean.Compiler.InlineAttrs": { + "relative_path": "lib/lean/Lean/Compiler/InlineAttrs.olean", + "sha256": "1dc521edbac6c28fb0abe0b1bfa72372d225b00d184228cb135fea3b3900583c" + }, + "Lean.Compiler.LCNF": { + "relative_path": "lib/lean/Lean/Compiler/LCNF.olean", + "sha256": "50ba85811e79db199dcc8528997fe62c599b3e36bae0bff0c56da744a975815e" + }, + "Lean.Compiler.LCNF.AlphaEqv": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/AlphaEqv.olean", + "sha256": "3e525daf1858d10b3c576598392a797f9bc77af47c88877a81f4b80f95e39f60" + }, + "Lean.Compiler.LCNF.AuxDeclCache": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/AuxDeclCache.olean", + "sha256": "e4ebfeac04cc04ab322e324c6b5cceb5fb0049899d323ace2185ed1d82f20460" + }, + "Lean.Compiler.LCNF.BaseTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/BaseTypes.olean", + "sha256": "5053822e35b6065475c75ea4121fb7c0e5572473b589a6318c23d8245cb91031" + }, + "Lean.Compiler.LCNF.Basic": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Basic.olean", + "sha256": "61a9c336f3fc892426f33ce054488c33e6c853038561acc10f6e68f1c4dae86f" + }, + "Lean.Compiler.LCNF.Bind": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Bind.olean", + "sha256": "ddcb0976ae13b967a67b86197dd84df7911382cfc311cc72f1643bcde382170e" + }, + "Lean.Compiler.LCNF.CSE": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CSE.olean", + "sha256": "0f30cf963d74e913c63d6a61eb2e6024a51aae3598e1bb7d67fe68e2571983b1" + }, + "Lean.Compiler.LCNF.Check": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Check.olean", + "sha256": "bfa8071c59de426aaa04e96c0c7cc9adabcba58266af88e878efc333efa217cc" + }, + "Lean.Compiler.LCNF.Closure": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Closure.olean", + "sha256": "8e07eaf84941feda5b4549dcbbfa53cd0981cf41053d3cb7604de6b37055b89c" + }, + "Lean.Compiler.LCNF.CompatibleTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CompatibleTypes.olean", + "sha256": "bbbd5d8598de30d40edc079da53afced3be253be5f5bc1ba5098b673a39178a7" + }, + "Lean.Compiler.LCNF.CompilerM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CompilerM.olean", + "sha256": "0dba55f8281250c8f7c8ca16d327e9c699a12bc22b7a740cc4494c9807071148" + }, + "Lean.Compiler.LCNF.ConfigOptions": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ConfigOptions.olean", + "sha256": "911b57609345802250709851c15ca20bb8b0c72d7cd38eb43691c09523cec4a7" + }, + "Lean.Compiler.LCNF.DeclHash": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/DeclHash.olean", + "sha256": "5e269b1f1ac7904fb9ebb77fe9805065fbb378fecf06eef5f123dc27a84b8555" + }, + "Lean.Compiler.LCNF.DependsOn": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/DependsOn.olean", + "sha256": "e7d096fac73063f27b1fc6f49c0eb5c4b7edb7075115cae9f2635e894fc7b070" + }, + "Lean.Compiler.LCNF.ElimDead": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ElimDead.olean", + "sha256": "477333313db8979680b9ee364d3075b5162225b83a69c60f18afca99f5f184c9" + }, + "Lean.Compiler.LCNF.ElimDeadBranches": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ElimDeadBranches.olean", + "sha256": "67ca5f89e780bfa7c0e62c0318b038421385dd3d9165ee207e2ba55a8edc3b50" + }, + "Lean.Compiler.LCNF.FVarUtil": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FVarUtil.olean", + "sha256": "d15ee92fbc441d2a5805f9fd5f851c49dd7267fc259d058273771168ce44b2b4" + }, + "Lean.Compiler.LCNF.FixedParams": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FixedParams.olean", + "sha256": "02e113791b21bc00471cc5e650e0167187e9b60993dc1627c1a0591cf9e928dc" + }, + "Lean.Compiler.LCNF.FloatLetIn": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FloatLetIn.olean", + "sha256": "aa1a425efb344b0216c4d87f584165e314acc54702788de99d359010f51cd5ef" + }, + "Lean.Compiler.LCNF.InferType": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/InferType.olean", + "sha256": "b91d6fbb425074a2e8296fbc557159c22b409e8f2ffa2dcf554f17d8d40f43fc" + }, + "Lean.Compiler.LCNF.Internalize": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Internalize.olean", + "sha256": "ddf26e1a280b6fcf208f46ca6683ffe8ef366527c447557a8852ba581abab6ff" + }, + "Lean.Compiler.LCNF.JoinPoints": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/JoinPoints.olean", + "sha256": "7955fd7fbf4caccbfc179059f5821358b5155dcce356bf20dbc5465989d12831" + }, + "Lean.Compiler.LCNF.LCtx": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/LCtx.olean", + "sha256": "798958fc2fdf1ff92063e6a5696a66dd32273a5eb6e04bfb217759105882742a" + }, + "Lean.Compiler.LCNF.LambdaLifting": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/LambdaLifting.olean", + "sha256": "16f7b519cd8548d6a88aff2c02029440110f13b2b009fb26afa4e8018d76f106" + }, + "Lean.Compiler.LCNF.Level": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Level.olean", + "sha256": "0ff39a4eec80e3c8047e926f4843c44eea5c1516e24c059c1c941d0948df7a6b" + }, + "Lean.Compiler.LCNF.Main": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Main.olean", + "sha256": "3678ef37331fb5a8b609a8ebfae188c589e87fef79ffff24533ea4059160f40c" + }, + "Lean.Compiler.LCNF.MonadScope": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/MonadScope.olean", + "sha256": "b16649d04910e51525f2513891c35417ccc791a9d19331355aea31cdbbe72a2e" + }, + "Lean.Compiler.LCNF.MonoTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/MonoTypes.olean", + "sha256": "6135eec86d64970beb3d9b00a2b74b30c0401784884cde565eefe186f42c7dac" + }, + "Lean.Compiler.LCNF.OtherDecl": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/OtherDecl.olean", + "sha256": "3cd7c6d125c8127901949761c55b36ebc963b7f28047fbb67221f978b966d0d0" + }, + "Lean.Compiler.LCNF.PassManager": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PassManager.olean", + "sha256": "0e7573909dd4940a95abface78fa3660072b1c6163a859562aec0e48c85451cf" + }, + "Lean.Compiler.LCNF.Passes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Passes.olean", + "sha256": "4b8864ccdfb3dabe28940e0e21f1726c3bbb252371c38e7992852f7da95ad0c9" + }, + "Lean.Compiler.LCNF.PhaseExt": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PhaseExt.olean", + "sha256": "8ed93f368be15928b930d48136cac9cac5eb283d269b53a4ccf9dc915480564c" + }, + "Lean.Compiler.LCNF.PrettyPrinter": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PrettyPrinter.olean", + "sha256": "484d0ba585c4943205d33a53df8d4735f52e7b4c65f9cc39a2dadece7e3ee769" + }, + "Lean.Compiler.LCNF.PullFunDecls": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PullFunDecls.olean", + "sha256": "20c18b55f55cc4cf61b95e3be8c6e2c2c1ce63af493e30d543534faf53550bc7" + }, + "Lean.Compiler.LCNF.PullLetDecls": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PullLetDecls.olean", + "sha256": "848f051bce9b922816355c97fc84232a03f85ed5fa38feed1b12ec6ff07eacac" + }, + "Lean.Compiler.LCNF.ReduceArity": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ReduceArity.olean", + "sha256": "bfb8fba4b4cf6829d092a9f3f4b5807108f7110296e6a9f71ceeb1f6ec90cd43" + }, + "Lean.Compiler.LCNF.ReduceJpArity": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ReduceJpArity.olean", + "sha256": "9bb32eeb3214ac55e1013ad425fd0c6852607391296751fddc2b8f4553f68c3e" + }, + "Lean.Compiler.LCNF.Renaming": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Renaming.olean", + "sha256": "bddac036add967291692acef307d3315af8aed4fd89a18d34311ac694ecf7816" + }, + "Lean.Compiler.LCNF.ScopeM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ScopeM.olean", + "sha256": "28822aa06f00730aba221eb7ae6cb264bb494bf25280246ffe6ff36c76243d28" + }, + "Lean.Compiler.LCNF.Simp": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp.olean", + "sha256": "58be16412a7c090265590410396a8263ede4d980f046637dff96f4a94d5d0b43" + }, + "Lean.Compiler.LCNF.Simp.Basic": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Basic.olean", + "sha256": "0bef1c90ca8bed6f80869aeb298d70671f82c7eec6f32e4576cca8d078d2ddfd" + }, + "Lean.Compiler.LCNF.Simp.Config": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Config.olean", + "sha256": "df3ec1bf55fe323c59d24d9e289dbb55b8e4e153686895cb4c6efbf33e693392" + }, + "Lean.Compiler.LCNF.Simp.ConstantFold": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/ConstantFold.olean", + "sha256": "63f240d9e408f7f34c53731a4b40b6784f639f7df3a130297aa52df6c5868ca3" + }, + "Lean.Compiler.LCNF.Simp.DefaultAlt": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.olean", + "sha256": "c7e68d37f1843b498489140e970e2caaa36548918cae5ddd881236065fdf9dfa" + }, + "Lean.Compiler.LCNF.Simp.DiscrM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/DiscrM.olean", + "sha256": "484a04366395e90ad0b5dd5c692a9e0da30c0918f50cca2ce7dc4459fbd6a590" + }, + "Lean.Compiler.LCNF.Simp.FunDeclInfo": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.olean", + "sha256": "63a8525abb01ee09dcd5fd7bb66fd5d5c9139ec98c9c4622594f19d042b7a81d" + }, + "Lean.Compiler.LCNF.Simp.InlineCandidate": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.olean", + "sha256": "04353a98d60a93bb13f644bc92b81233d665eff28f5e2594d7b7a45ef883572c" + }, + "Lean.Compiler.LCNF.Simp.InlineProj": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineProj.olean", + "sha256": "949390558396b4e92eb72823f8f123ce6a6a310b8e77234bd741d36a8158c1a4" + }, + "Lean.Compiler.LCNF.Simp.JpCases": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/JpCases.olean", + "sha256": "88b4036ff347ff9a1678d5eb585ca362ae0090e9de2b646e2efe90f4dc9a2328" + }, + "Lean.Compiler.LCNF.Simp.Main": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Main.olean", + "sha256": "0ae14b3273b7cb404efb46440a25ac0aaf8e49cd31eb57bea19b7833c219365b" + }, + "Lean.Compiler.LCNF.Simp.SimpM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpM.olean", + "sha256": "df1538b785d0aaa55d1d73ab4b63fd693959896c231a826d39818bddcb6b0d08" + }, + "Lean.Compiler.LCNF.Simp.SimpValue": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpValue.olean", + "sha256": "5de57ce90ffa7ba15734b33a8ad519ee98115c1e83f7ce047fcad5eb03bbe297" + }, + "Lean.Compiler.LCNF.Simp.Used": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Used.olean", + "sha256": "a4983d2052c84460309e9808f3d4518e65f78d7097eb707772abe71ba2bf5e4c" + }, + "Lean.Compiler.LCNF.SpecInfo": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/SpecInfo.olean", + "sha256": "4d9ce851163d5921bf6573eaf6b3d68442709f279fa96b23336b7b32d58a440b" + }, + "Lean.Compiler.LCNF.Specialize": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Specialize.olean", + "sha256": "9ecbcb6a200ec1984ed5231ba427a912a51177fbbfcf2d7ae584aba44397758b" + }, + "Lean.Compiler.LCNF.Testing": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Testing.olean", + "sha256": "8f082e72af8eb9e42eda181444b84c6a71e1a38e65b92e335abe9fda5f77d9cd" + }, + "Lean.Compiler.LCNF.ToDecl": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToDecl.olean", + "sha256": "edd9baf0d9dcc767a237f6ab3d3b8be89f5f7a8486579a61d92f3ee55c85ec8b" + }, + "Lean.Compiler.LCNF.ToExpr": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToExpr.olean", + "sha256": "97eb45572133529cfcd4d6581a8a27c406477191a1b027b7dbc8bbaf45bab62d" + }, + "Lean.Compiler.LCNF.ToLCNF": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToLCNF.olean", + "sha256": "3d2ca7cd028efcacaa2882570d10dd518c5a73860de6ceebb68658b3439607ab" + }, + "Lean.Compiler.LCNF.ToMono": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToMono.olean", + "sha256": "9c42901d6b7192fd65b8a5f809566805abc90063211569894835a17be53820b3" + }, + "Lean.Compiler.LCNF.Types": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Types.olean", + "sha256": "19db15eb19ec6842ff578614e85a7323642539fbb955b5912c170dec0eae2292" + }, + "Lean.Compiler.LCNF.Util": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Util.olean", + "sha256": "2a73fb99a3cb08e8a41425bc5ca182aaaa401508e583d6305a70868ea56208c3" + }, + "Lean.Compiler.Main": { + "relative_path": "lib/lean/Lean/Compiler/Main.olean", + "sha256": "9dc59f3522ff5c16389fc3454829050f7613c2f4175037beab5c0e4f86468de3" + }, + "Lean.Compiler.NameMangling": { + "relative_path": "lib/lean/Lean/Compiler/NameMangling.olean", + "sha256": "52aa954ea4c255de3c15968d309de875c4b03892e28568614f5b9e5d6bc3f38c" + }, + "Lean.Compiler.NeverExtractAttr": { + "relative_path": "lib/lean/Lean/Compiler/NeverExtractAttr.olean", + "sha256": "8efc3ead298e537a086cd425cfd99e6cd10185c78b13d8654d04435ed0f2c577" + }, + "Lean.Compiler.NoncomputableAttr": { + "relative_path": "lib/lean/Lean/Compiler/NoncomputableAttr.olean", + "sha256": "e396574927b99c247f101c8248a0a09cdff7a46e3809fb4589f0dcc4fba6d106" + }, + "Lean.Compiler.Old": { + "relative_path": "lib/lean/Lean/Compiler/Old.olean", + "sha256": "abc232855b58731d54ab07783fa46843208c6deace78b6b370cf476353c3e46d" + }, + "Lean.Compiler.Options": { + "relative_path": "lib/lean/Lean/Compiler/Options.olean", + "sha256": "b86376be11dc414b13c5a54d25cb7817f5660a01981e99d7f45f587f9a2933df" + }, + "Lean.Compiler.Specialize": { + "relative_path": "lib/lean/Lean/Compiler/Specialize.olean", + "sha256": "401294d22aa31d66ffea73cc8e81b84069c82bbf437abe562251e13bfd93394a" + }, + "Lean.CoreM": { + "relative_path": "lib/lean/Lean/CoreM.olean", + "sha256": "5e46337730d7e521a4ee2760c1adaea3e2862c5cc8006afed50f290ca2aafea7" + }, + "Lean.Data": { + "relative_path": "lib/lean/Lean/Data.olean", + "sha256": "3ea6fcf75dec1adae7990d5823a1527d3306689cb440e3c5ecea7b7ea7aab07d" + }, + "Lean.Data.Array": { + "relative_path": "lib/lean/Lean/Data/Array.olean", + "sha256": "d21870a1441bb3b382f82f64457d1fabeb8ab046e4147892433f89143f8481ea" + }, + "Lean.Data.AssocList": { + "relative_path": "lib/lean/Lean/Data/AssocList.olean", + "sha256": "9a08b7424a24c46dd2284b4c7b8692181a5e608302ae500e6445d627ea448d41" + }, + "Lean.Data.DeclarationRange": { + "relative_path": "lib/lean/Lean/Data/DeclarationRange.olean", + "sha256": "0c7a925cebc8a6c0405a7f6741afe5ecebca751b7141fc36518c902615167d6d" + }, + "Lean.Data.Format": { + "relative_path": "lib/lean/Lean/Data/Format.olean", + "sha256": "64c298e5e84c96a54830f2e1cf59e23ecd5c91c45336d9e99aa368884d8a9069" + }, + "Lean.Data.FuzzyMatching": { + "relative_path": "lib/lean/Lean/Data/FuzzyMatching.olean", + "sha256": "558ddc6d5ca38eada259e0fa5ad47478d15ba0f7878a7becb1c04394e7e98b19" + }, + "Lean.Data.Json": { + "relative_path": "lib/lean/Lean/Data/Json.olean", + "sha256": "3839c3f8868485cc28a91248414f8d7b15e3785cadd116d77d254f3acef1b768" + }, + "Lean.Data.Json.Basic": { + "relative_path": "lib/lean/Lean/Data/Json/Basic.olean", + "sha256": "d4a1599c4250412e05b960339e4898b1b5a9dde3f0292029eb02947f7df091cb" + }, + "Lean.Data.Json.Elab": { + "relative_path": "lib/lean/Lean/Data/Json/Elab.olean", + "sha256": "75bd0e3c0b0e50b6890616aff9499849bcc80f783737fb06762b1e638ce6641a" + }, + "Lean.Data.Json.FromToJson": { + "relative_path": "lib/lean/Lean/Data/Json/FromToJson.olean", + "sha256": "bc5266fe22b0d8289fac5e2194f2f3a5c0efa79dc538a96dee258041d8296066" + }, + "Lean.Data.Json.Parser": { + "relative_path": "lib/lean/Lean/Data/Json/Parser.olean", + "sha256": "eb9a4c2f421543848f9e21ff12b4cbf7ec42e0b339c4cc81725e9be627307a46" + }, + "Lean.Data.Json.Printer": { + "relative_path": "lib/lean/Lean/Data/Json/Printer.olean", + "sha256": "18bc6d83251888a60b8e091d5a7cd832d1733cca7cf8fc0afd197db2cd4bac6d" + }, + "Lean.Data.Json.Stream": { + "relative_path": "lib/lean/Lean/Data/Json/Stream.olean", + "sha256": "bbb7aea03b82669971dae676811dc7c4d2f91530d1b95dec8186faad10a2690e" + }, + "Lean.Data.JsonRpc": { + "relative_path": "lib/lean/Lean/Data/JsonRpc.olean", + "sha256": "324ae0dd9b94d607f0bd3634ff28ee91747e533225a1787ccffd3cdff6e78934" + }, + "Lean.Data.KVMap": { + "relative_path": "lib/lean/Lean/Data/KVMap.olean", + "sha256": "b69b36c839f87d7982c58dca02516af56a62b6e6f8cfed957727ab6fa5bdc3ac" + }, + "Lean.Data.LBool": { + "relative_path": "lib/lean/Lean/Data/LBool.olean", + "sha256": "e53d3d54cbdd02e971cade214336ed88039217dac49083fe9e2884774bc65980" + }, + "Lean.Data.LOption": { + "relative_path": "lib/lean/Lean/Data/LOption.olean", + "sha256": "ef57f5ca74f00d15e3353c7372bfd6539fad887f98eeb1405fc120f63fbc5450" + }, + "Lean.Data.Lsp": { + "relative_path": "lib/lean/Lean/Data/Lsp.olean", + "sha256": "5e8f95b054cf4f0bd78d09d3b60f8212677ebbcc9669810a4d555c12dbbe2c9d" + }, + "Lean.Data.Lsp.Basic": { + "relative_path": "lib/lean/Lean/Data/Lsp/Basic.olean", + "sha256": "10bd55152d2d3195bc716586b88ba354117a1610a511d4ef45e5bae4e47da591" + }, + "Lean.Data.Lsp.CancelParams": { + "relative_path": "lib/lean/Lean/Data/Lsp/CancelParams.olean", + "sha256": "34d5045104a2ad488db0eef5506fb5d152a50eb3b218963958249909e0693fc5" + }, + "Lean.Data.Lsp.Capabilities": { + "relative_path": "lib/lean/Lean/Data/Lsp/Capabilities.olean", + "sha256": "ea086554ff056336572f390c3a721392fc0a091b1e3ad5b11a1cbcfde01acb7d" + }, + "Lean.Data.Lsp.Client": { + "relative_path": "lib/lean/Lean/Data/Lsp/Client.olean", + "sha256": "66969eb1b65d7b7c0785a7410441db19c0684e49523b99141c98e9d6de265b1c" + }, + "Lean.Data.Lsp.CodeActions": { + "relative_path": "lib/lean/Lean/Data/Lsp/CodeActions.olean", + "sha256": "aaf6f59e076f612c399dc153b8655c630e5e8d3900d0c34e0754af24363fb5db" + }, + "Lean.Data.Lsp.Communication": { + "relative_path": "lib/lean/Lean/Data/Lsp/Communication.olean", + "sha256": "ff24b3db4d74dee7c02f3b312dfbcd8808ad401059a6e620467de85d2eae4b02" + }, + "Lean.Data.Lsp.Diagnostics": { + "relative_path": "lib/lean/Lean/Data/Lsp/Diagnostics.olean", + "sha256": "fab551e98e02150756f22d91f045edd2885311b0f2acd3b9f2518a03ac5315d1" + }, + "Lean.Data.Lsp.Extra": { + "relative_path": "lib/lean/Lean/Data/Lsp/Extra.olean", + "sha256": "328a92e6483fa971c03bc5c81df3fb8d54638f2b63589227cd51c150c184c6b3" + }, + "Lean.Data.Lsp.InitShutdown": { + "relative_path": "lib/lean/Lean/Data/Lsp/InitShutdown.olean", + "sha256": "6a4a2bdd2b9c291879021e2ac05ebb1766e5261b8eacce52931e0e3456e83582" + }, + "Lean.Data.Lsp.Internal": { + "relative_path": "lib/lean/Lean/Data/Lsp/Internal.olean", + "sha256": "7ac2bdcbc98918536b8dbc74f690ef33efa3d8f262d9da00b9745674124fa0f2" + }, + "Lean.Data.Lsp.Ipc": { + "relative_path": "lib/lean/Lean/Data/Lsp/Ipc.olean", + "sha256": "4655e8e87c7be2dee1388ddf2859e22126ff8e459049c7ae78b1f8c423523f60" + }, + "Lean.Data.Lsp.LanguageFeatures": { + "relative_path": "lib/lean/Lean/Data/Lsp/LanguageFeatures.olean", + "sha256": "9076799ae1e2a126180f4b65b4ba70bd0587000bbba075a49ede2e652940f648" + }, + "Lean.Data.Lsp.TextSync": { + "relative_path": "lib/lean/Lean/Data/Lsp/TextSync.olean", + "sha256": "661e837c6457b276db0fc3ff7b83c025daed1e81f1d119fa2bd8d8f703507212" + }, + "Lean.Data.Lsp.Utf16": { + "relative_path": "lib/lean/Lean/Data/Lsp/Utf16.olean", + "sha256": "3b966b6509a39ebdcfad59afb26a19c8b1ba431328424700a06d2f157e4628a2" + }, + "Lean.Data.Lsp.Window": { + "relative_path": "lib/lean/Lean/Data/Lsp/Window.olean", + "sha256": "80692ee76bcb8185fa3f79531823189b4aec6a02471db5978a0d41c260482632" + }, + "Lean.Data.Lsp.Workspace": { + "relative_path": "lib/lean/Lean/Data/Lsp/Workspace.olean", + "sha256": "9e2c734db08fbbf1a7eecf54afa2f4e6b2c4823fbfec4a700ca1ede9cbf099a8" + }, + "Lean.Data.Name": { + "relative_path": "lib/lean/Lean/Data/Name.olean", + "sha256": "608a86b16dc2e68888780aace6bf3c444be9ca982fbe05c0722b24a5941114cf" + }, + "Lean.Data.NameMap": { + "relative_path": "lib/lean/Lean/Data/NameMap.olean", + "sha256": "ad3950d1e39be7f250a74794819b4c299fd8aad0b95a8ebf383f713c4648667b" + }, + "Lean.Data.NameTrie": { + "relative_path": "lib/lean/Lean/Data/NameTrie.olean", + "sha256": "7b0032738d09c94b21eedfb74e920ce5781c864cc1541e28b9216f2296a3f50a" + }, + "Lean.Data.OpenDecl": { + "relative_path": "lib/lean/Lean/Data/OpenDecl.olean", + "sha256": "11d3c7dfac1707956e6ad5f8d99249971cefd2439d94b1042efcf1147a609848" + }, + "Lean.Data.Options": { + "relative_path": "lib/lean/Lean/Data/Options.olean", + "sha256": "69369d0818d266e890c00e318f186fdb767b308ec0ffa12c8d498ad8ab8dafd4" + }, + "Lean.Data.PersistentArray": { + "relative_path": "lib/lean/Lean/Data/PersistentArray.olean", + "sha256": "14912531f574091502391030308b9fe1d9d6751b946af2614e19472c009ed084" + }, + "Lean.Data.PersistentHashMap": { + "relative_path": "lib/lean/Lean/Data/PersistentHashMap.olean", + "sha256": "1eb926bd3f03db27a647b1dd1ae1606722f7f8bd555a8c9e4197e00d69af8819" + }, + "Lean.Data.PersistentHashSet": { + "relative_path": "lib/lean/Lean/Data/PersistentHashSet.olean", + "sha256": "bbe6fe443d42b01b3ee7c45908dd2761f3e0996e47c6d05531bfd326b82a1927" + }, + "Lean.Data.Position": { + "relative_path": "lib/lean/Lean/Data/Position.olean", + "sha256": "1031cb2dd0a833b50284a503a02c8f71490d93182219e9b2e43c536370992719" + }, + "Lean.Data.PrefixTree": { + "relative_path": "lib/lean/Lean/Data/PrefixTree.olean", + "sha256": "1cfc295f1fee5de8bb9c641f6c6a67ed4d24b3cea24af1b44ce8baae361860d7" + }, + "Lean.Data.RArray": { + "relative_path": "lib/lean/Lean/Data/RArray.olean", + "sha256": "6846f637e7f46e1ed281043406f082980d0db3c56fd1fc34fd080be3e743b11a" + }, + "Lean.Data.RBMap": { + "relative_path": "lib/lean/Lean/Data/RBMap.olean", + "sha256": "ecdafd26877ccf099c7ad634090493a314130ddb1f511402e869f833179f677a" + }, + "Lean.Data.RBTree": { + "relative_path": "lib/lean/Lean/Data/RBTree.olean", + "sha256": "4a1139cda04f91a7a78086a92cbfa53af7cd5ed0b04f50f388e91caba39e72c4" + }, + "Lean.Data.SMap": { + "relative_path": "lib/lean/Lean/Data/SMap.olean", + "sha256": "1af0bd0e0119f17204517f5b0e3ae76e582ad139d167e04d4b872c3b80fb9446" + }, + "Lean.Data.SSet": { + "relative_path": "lib/lean/Lean/Data/SSet.olean", + "sha256": "3ce020534c8de2eaaf8b72fdc30dfeff283d9fdf9cb402ee7eaa9d6e06bed49a" + }, + "Lean.Data.Trie": { + "relative_path": "lib/lean/Lean/Data/Trie.olean", + "sha256": "425b99d0861d274a027650fd85e91fe2ea4c8d2b332c26f05ce3faa69f8b22a9" + }, + "Lean.Data.Xml": { + "relative_path": "lib/lean/Lean/Data/Xml.olean", + "sha256": "3051520fc1f5e8969c97cd69b2e390cc0291e716af0304ca910917ca40c395b6" + }, + "Lean.Data.Xml.Basic": { + "relative_path": "lib/lean/Lean/Data/Xml/Basic.olean", + "sha256": "b78909fa2d132e4733174d2ce5edb87022889a3c00034a5600c37366d1249798" + }, + "Lean.Data.Xml.Parser": { + "relative_path": "lib/lean/Lean/Data/Xml/Parser.olean", + "sha256": "ef6845551edad3dd21f97bc12796643808c3e736f98ea92cd3836de8d120f896" + }, + "Lean.Declaration": { + "relative_path": "lib/lean/Lean/Declaration.olean", + "sha256": "34e3ddb2ffb4c62a725faaa32d867b47ce0f0e88e4d05b88cb4b0e8d06afcf14" + }, + "Lean.DeclarationRange": { + "relative_path": "lib/lean/Lean/DeclarationRange.olean", + "sha256": "0acae02702629cf9d8d1914af744e4616b1a11ec0c36b87b061ddb544de6c77f" + }, + "Lean.DocString": { + "relative_path": "lib/lean/Lean/DocString.olean", + "sha256": "a3acd1c0a67f2041105b56e4358104b944cccadaf6282f51d2d6c92c588e1322" + }, + "Lean.DocString.Add": { + "relative_path": "lib/lean/Lean/DocString/Add.olean", + "sha256": "4e2edfbc5d94f30cb22899dd904adf4e886c31d74a14b4867d5e6990ae6bef1f" + }, + "Lean.DocString.Extension": { + "relative_path": "lib/lean/Lean/DocString/Extension.olean", + "sha256": "62da3e2b1a78c1564bc55d7a62a3dd0bf3a5bb680c78b064545b34f22ff5f594" + }, + "Lean.DocString.Links": { + "relative_path": "lib/lean/Lean/DocString/Links.olean", + "sha256": "cb06ad02ed13e3becad26e41c65955dc450c95efd3c03c7e243480eb441a280e" + }, + "Lean.Elab": { + "relative_path": "lib/lean/Lean/Elab.olean", + "sha256": "fb002575329248f441db46568924da0347c0fc94899a897d260ed87e8b060d3a" + }, + "Lean.Elab.App": { + "relative_path": "lib/lean/Lean/Elab/App.olean", + "sha256": "7f2ef3399ca2be27e53f782db9299d1262626709416ecbde404d3044360c20e2" + }, + "Lean.Elab.Arg": { + "relative_path": "lib/lean/Lean/Elab/Arg.olean", + "sha256": "43fcac69dfb8c829f70e5c25b51a6864a5926de26a7f59d59b3434c77d2a4b70" + }, + "Lean.Elab.Attributes": { + "relative_path": "lib/lean/Lean/Elab/Attributes.olean", + "sha256": "a5a66de9739bb05ccb5303622d7e370cb631c209bade735a5a9263a16f2e994e" + }, + "Lean.Elab.AutoBound": { + "relative_path": "lib/lean/Lean/Elab/AutoBound.olean", + "sha256": "bf849b5b3131ab0c7cd465721e2bff12b3007ab05787e45d9c45cfe31dbcd8d9" + }, + "Lean.Elab.AuxDef": { + "relative_path": "lib/lean/Lean/Elab/AuxDef.olean", + "sha256": "a48e7422c13ae3730a198f9535a2a4f1d52af7ddff79a8e3e44f17e382bded85" + }, + "Lean.Elab.BinderPredicates": { + "relative_path": "lib/lean/Lean/Elab/BinderPredicates.olean", + "sha256": "f19b46d5afb2ed4f25501c99c971d43ef80056b1b54537acfab9b844b4baa033" + }, + "Lean.Elab.Binders": { + "relative_path": "lib/lean/Lean/Elab/Binders.olean", + "sha256": "5382842df889f912fcdc6829b4da03bccb31d24f644c9dc267d549a049f1f6e2" + }, + "Lean.Elab.BindersUtil": { + "relative_path": "lib/lean/Lean/Elab/BindersUtil.olean", + "sha256": "dab5459f96c9af7151e019d42c16f735587fe9d2e465680af5542694045d024e" + }, + "Lean.Elab.BuiltinCommand": { + "relative_path": "lib/lean/Lean/Elab/BuiltinCommand.olean", + "sha256": "e8873e484147230a2d52ed220e5d991242e27b35cb3e04ac44a121b4e60674e6" + }, + "Lean.Elab.BuiltinEvalCommand": { + "relative_path": "lib/lean/Lean/Elab/BuiltinEvalCommand.olean", + "sha256": "c9ffac4f0e2a910c88b947565e7186e7496b2bb71a51d3efa8b57df1716e2721" + }, + "Lean.Elab.BuiltinNotation": { + "relative_path": "lib/lean/Lean/Elab/BuiltinNotation.olean", + "sha256": "a8854418983a3521ac0009f1d1bc5886cbee99a420b5853c955e2bba669c8a01" + }, + "Lean.Elab.BuiltinTerm": { + "relative_path": "lib/lean/Lean/Elab/BuiltinTerm.olean", + "sha256": "d1c759f9d638631d8c7fcc61d904c4b3022e467c85374536404b62bcae94dbfa" + }, + "Lean.Elab.Calc": { + "relative_path": "lib/lean/Lean/Elab/Calc.olean", + "sha256": "517858cf70dbd5a3567f8c7efa08ebb072924f0ab475d1ea392d2d71f404a067" + }, + "Lean.Elab.CheckTactic": { + "relative_path": "lib/lean/Lean/Elab/CheckTactic.olean", + "sha256": "4ee79b7594813f45a0be34f47d7dcb9040038d236c08d62d075bb533cd209a06" + }, + "Lean.Elab.Command": { + "relative_path": "lib/lean/Lean/Elab/Command.olean", + "sha256": "d70527ba43f3a254e944e0951c798896a50306d8eb16d8caf346cc2c8de2037e" + }, + "Lean.Elab.ComputedFields": { + "relative_path": "lib/lean/Lean/Elab/ComputedFields.olean", + "sha256": "8aa833985762117070e65be8efd47e1105136cb60c5dce5bd1c3d9b777829778" + }, + "Lean.Elab.Config": { + "relative_path": "lib/lean/Lean/Elab/Config.olean", + "sha256": "ab8b7261941780805d87f6cd63432afa539d6810b16b3728dfa0be2722c36bd4" + }, + "Lean.Elab.DeclModifiers": { + "relative_path": "lib/lean/Lean/Elab/DeclModifiers.olean", + "sha256": "082924ed9a1233708427a204ac06d00058e16efc75a4fbf2b05260bd4b4d23d9" + }, + "Lean.Elab.DeclNameGen": { + "relative_path": "lib/lean/Lean/Elab/DeclNameGen.olean", + "sha256": "3074bf25442d70036c97fadd21d83594e0b375d89a203068ccdcfbd5ac0778ab" + }, + "Lean.Elab.DeclUtil": { + "relative_path": "lib/lean/Lean/Elab/DeclUtil.olean", + "sha256": "60ed8c5034fdb91d96f0d29a947ae510e6aa2d2c8144c82d941b33d8a236cef2" + }, + "Lean.Elab.Declaration": { + "relative_path": "lib/lean/Lean/Elab/Declaration.olean", + "sha256": "60127f7068dd6080656cc0b8fc28c04e2297a8c22ed96c5ebc6a940bb746f3d6" + }, + "Lean.Elab.DeclarationRange": { + "relative_path": "lib/lean/Lean/Elab/DeclarationRange.olean", + "sha256": "4f693d72400c7b0083dc440da6cd99962551af0a31fcdc5f23ad218b4c1cf9ba" + }, + "Lean.Elab.DefView": { + "relative_path": "lib/lean/Lean/Elab/DefView.olean", + "sha256": "4b0690fe469dcc04235e5f1db28aca28c0a1d1890622e846894836d8465cbe27" + }, + "Lean.Elab.Deriving": { + "relative_path": "lib/lean/Lean/Elab/Deriving.olean", + "sha256": "ce2343744dcd7113446dba7686175adce1b219cfa3e2a02b883dc96c83ba7492" + }, + "Lean.Elab.Deriving.BEq": { + "relative_path": "lib/lean/Lean/Elab/Deriving/BEq.olean", + "sha256": "9ee4fb8b5a18bc9a71a2188781679f93e6f7084d7166d0abca3348a2ea069748" + }, + "Lean.Elab.Deriving.Basic": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Basic.olean", + "sha256": "1ce625bec288e07f709d51fce4479fa7c90fa26229a535dbf101fb15f094b1f4" + }, + "Lean.Elab.Deriving.DecEq": { + "relative_path": "lib/lean/Lean/Elab/Deriving/DecEq.olean", + "sha256": "02f7fe725e01d8646ab570659983869355626c34eba194247edcef78ec767253" + }, + "Lean.Elab.Deriving.FromToJson": { + "relative_path": "lib/lean/Lean/Elab/Deriving/FromToJson.olean", + "sha256": "02247476a022d1f65eedd2bd2edc694bd4dad5f4766c175b99613a7f7573c7a8" + }, + "Lean.Elab.Deriving.Hashable": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Hashable.olean", + "sha256": "d6a8f5480a4d92cad91e38425026a73585933acdea29983327c6847c2b262f88" + }, + "Lean.Elab.Deriving.Inhabited": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Inhabited.olean", + "sha256": "39f9db1e14cd9748ee9fa5d6a892f8aea231b94d854d6b18d8386ef424f71e2d" + }, + "Lean.Elab.Deriving.Nonempty": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Nonempty.olean", + "sha256": "99cf8010b9439d9586ec46c94e4667b1a779478c343adeddb8744e3e9a40b8f6" + }, + "Lean.Elab.Deriving.Ord": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Ord.olean", + "sha256": "4a047b2d5dfcd783ad4004184a3752bd8a7ab07dd8a694e097d1d935e2935e9e" + }, + "Lean.Elab.Deriving.Repr": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Repr.olean", + "sha256": "6b3f39ea3a48df4fcdc3f54f23443e518331051c09c139e251e24e08830be248" + }, + "Lean.Elab.Deriving.SizeOf": { + "relative_path": "lib/lean/Lean/Elab/Deriving/SizeOf.olean", + "sha256": "e92edf4220bbfd45b65b0fec728a4e4d4cd94681b03bba266afa98e2615b9723" + }, + "Lean.Elab.Deriving.ToExpr": { + "relative_path": "lib/lean/Lean/Elab/Deriving/ToExpr.olean", + "sha256": "d6523a528599743a7df654f5743b1528f21614d72a44f3abe2aa8a28d3bd648d" + }, + "Lean.Elab.Deriving.TypeName": { + "relative_path": "lib/lean/Lean/Elab/Deriving/TypeName.olean", + "sha256": "c4792fb38b5aeb5ea5a62636aff5f757d361aa8efd4f18c67004aae538a459b7" + }, + "Lean.Elab.Deriving.Util": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Util.olean", + "sha256": "c12884adaa0c778910c1bb93eaed6108bdaea5154acf789cfade6ed2d07bc557" + }, + "Lean.Elab.Do": { + "relative_path": "lib/lean/Lean/Elab/Do.olean", + "sha256": "f7edfae85cb0c26decf417da2b632bd988396e64b591ed1e83d80007039803f3" + }, + "Lean.Elab.ElabRules": { + "relative_path": "lib/lean/Lean/Elab/ElabRules.olean", + "sha256": "f9382a01adb96c2df46c91c3b8f089161a092e303fa6c21f6ee11e052b6ff4a2" + }, + "Lean.Elab.Eval": { + "relative_path": "lib/lean/Lean/Elab/Eval.olean", + "sha256": "7c71d21984db41ed525d830c97c499f6b6bb94896b3ef708a3f0f3c3992816be" + }, + "Lean.Elab.Exception": { + "relative_path": "lib/lean/Lean/Elab/Exception.olean", + "sha256": "c1966d832888ab689c6fb710ec26064030ce9114979ba2be5b55438d3a588875" + }, + "Lean.Elab.Extra": { + "relative_path": "lib/lean/Lean/Elab/Extra.olean", + "sha256": "e04aa742507f1f8ce71235aee3e0410a0349afcce02af8033eda84793fd3cb07" + }, + "Lean.Elab.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Frontend.olean", + "sha256": "8a78aa55e40dc042d0ef7ee6eb0ac9a8e32e69499d416edbeaf41a87389bdfcc" + }, + "Lean.Elab.GenInjective": { + "relative_path": "lib/lean/Lean/Elab/GenInjective.olean", + "sha256": "71e9b7c42d5c7ba361b678074beaa897c5d59561f84b92e61be9bce93ba1516c" + }, + "Lean.Elab.GuardMsgs": { + "relative_path": "lib/lean/Lean/Elab/GuardMsgs.olean", + "sha256": "c31104fae5363b5f9b40b457899730f0bf09cb532dbdba7019768a491bfbe033" + }, + "Lean.Elab.Import": { + "relative_path": "lib/lean/Lean/Elab/Import.olean", + "sha256": "942d562b54b0f9c16191c1dc631a63c61242e662bb6b20a96c21aca07febd4a2" + }, + "Lean.Elab.Inductive": { + "relative_path": "lib/lean/Lean/Elab/Inductive.olean", + "sha256": "c0773865c8c9ed8cf8dd1799819033f043b272ece64a17dcfca9c393fc65d4d1" + }, + "Lean.Elab.InfoTree": { + "relative_path": "lib/lean/Lean/Elab/InfoTree.olean", + "sha256": "e70760b7a719b09450ee47e653758f4b04bf770d2540ecdad9c68e1ff9dcffb1" + }, + "Lean.Elab.InfoTree.InlayHints": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/InlayHints.olean", + "sha256": "9ba09f4498147935a7cc795b4dbeb9c50d057cf40bd69dc080cabcb53c6f528a" + }, + "Lean.Elab.InfoTree.Main": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/Main.olean", + "sha256": "1d24d8fe2cf5c200615e2441353a8f2ccb183bd92272ad1a91c143f037e59159" + }, + "Lean.Elab.InfoTree.Types": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/Types.olean", + "sha256": "f5ef787b574b053eb6c4dedb63628dcab9c3323860e03b9f1689b919f5a43ea6" + }, + "Lean.Elab.InfoTrees": { + "relative_path": "lib/lean/Lean/Elab/InfoTrees.olean", + "sha256": "6d9c5aef462dd3f15682d204244f1f309fe21ef6ef10afb72805a052e7360f97" + }, + "Lean.Elab.InheritDoc": { + "relative_path": "lib/lean/Lean/Elab/InheritDoc.olean", + "sha256": "13baf3bf2e721fe666937e96ef2e4c05b29802168cdbd1dbcb5024ff90c12808" + }, + "Lean.Elab.LetRec": { + "relative_path": "lib/lean/Lean/Elab/LetRec.olean", + "sha256": "25dedf0d0c914e81ba7d5f40d8cac33b777717b8587e668add128fd532e0a129" + }, + "Lean.Elab.Level": { + "relative_path": "lib/lean/Lean/Elab/Level.olean", + "sha256": "6a2e73a7585f6edbc7aa991ced908c75f6a0b6677c602f9688c2187f4e424507" + }, + "Lean.Elab.Macro": { + "relative_path": "lib/lean/Lean/Elab/Macro.olean", + "sha256": "6d4ddaaad390cc33240dabfe92351ce1b4475bc00e2bfc13a1e7d1275b731e9c" + }, + "Lean.Elab.MacroArgUtil": { + "relative_path": "lib/lean/Lean/Elab/MacroArgUtil.olean", + "sha256": "66055bb8c852b726c6c019c0ea30d9680da2b79d0f7281bae9dd6aac4e69c745" + }, + "Lean.Elab.MacroRules": { + "relative_path": "lib/lean/Lean/Elab/MacroRules.olean", + "sha256": "87258a9723089efebfd06f4fd21de2d60819043181f411caf52db4e4d61c9269" + }, + "Lean.Elab.Match": { + "relative_path": "lib/lean/Lean/Elab/Match.olean", + "sha256": "f96ca7fa6ad4572f2e70f9caf0017d6b703f6343f966146652b6a4567e075ecb" + }, + "Lean.Elab.MatchAltView": { + "relative_path": "lib/lean/Lean/Elab/MatchAltView.olean", + "sha256": "bcc410a60ab916611cd1314ccb349d1e6291534e2f54f1acc879ae5dd92e127e" + }, + "Lean.Elab.MatchExpr": { + "relative_path": "lib/lean/Lean/Elab/MatchExpr.olean", + "sha256": "c4a41299da81eb484f5ed9c1f11a2ea202f408aedd6f89eec668ec2309a05668" + }, + "Lean.Elab.Mixfix": { + "relative_path": "lib/lean/Lean/Elab/Mixfix.olean", + "sha256": "9a948b85420661584f24c9c1adb6e9de9d89e53b1c9a71f91ebc0c27b7664c6b" + }, + "Lean.Elab.MutualDef": { + "relative_path": "lib/lean/Lean/Elab/MutualDef.olean", + "sha256": "1f9b71fb58473a9ed15668ce35710aadb27f433aa3d403cb989ae40f4f22c468" + }, + "Lean.Elab.MutualInductive": { + "relative_path": "lib/lean/Lean/Elab/MutualInductive.olean", + "sha256": "cadab2c90a0b83ef83df3405057155eceeb5335b3496f9f380677d08a5d03cf0" + }, + "Lean.Elab.Notation": { + "relative_path": "lib/lean/Lean/Elab/Notation.olean", + "sha256": "48412518cf3a658eae49c64cc1467c82b71bc9d8210744b25af28f2c920335ed" + }, + "Lean.Elab.Open": { + "relative_path": "lib/lean/Lean/Elab/Open.olean", + "sha256": "871d01b5e8a7d02623aae31186f1d6440de1e88cfa5a61aa65d49bc339b801b1" + }, + "Lean.Elab.ParseImportsFast": { + "relative_path": "lib/lean/Lean/Elab/ParseImportsFast.olean", + "sha256": "e7c263fcce8f9f845a93cbacd4270d29f526c6f49542bfd3fabda67b7bf6a78a" + }, + "Lean.Elab.PatternVar": { + "relative_path": "lib/lean/Lean/Elab/PatternVar.olean", + "sha256": "cc24f76e8a73bb74fa086ffc0ca15b83727e9fe862a2bebeb5ef951d328568ec" + }, + "Lean.Elab.PreDefinition": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition.olean", + "sha256": "cf08e93464411219890b4cb1bab8e1610a70a4fb65e43b50bd739539ef367547" + }, + "Lean.Elab.PreDefinition.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Basic.olean", + "sha256": "e37a918d0df8abd0297fe32ffe904d12705e71a5098c0c3299788bec711135d8" + }, + "Lean.Elab.PreDefinition.EqUnfold": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/EqUnfold.olean", + "sha256": "3461b20ecf2a82f12d463ada0c8741fa66ee5d67ad1f6baf6e744166ccecb007" + }, + "Lean.Elab.PreDefinition.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Eqns.olean", + "sha256": "19c4d86d1bc0cb30d41db8fee326500bff23ce73f35d422a577d118a346c3f4c" + }, + "Lean.Elab.PreDefinition.FixedParams": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/FixedParams.olean", + "sha256": "0b2ab92716760dec18c20cef92a923f45ced48471005b89968dc44cc042a7787" + }, + "Lean.Elab.PreDefinition.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Main.olean", + "sha256": "e9da272ef4937c5dea929555f1afb9c0bc5e546c46ba077dba6ecad53fc039f9" + }, + "Lean.Elab.PreDefinition.MkInhabitant": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/MkInhabitant.olean", + "sha256": "01386a0e9abb41906ebeff2b51300a35bdb976fd8f5414996e90edbe7aa71535" + }, + "Lean.Elab.PreDefinition.Mutual": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Mutual.olean", + "sha256": "7727402f03f91af4db7349660aa7d8ea7512be3c6a5a9745e4528df91b2d86e2" + }, + "Lean.Elab.PreDefinition.Nonrec.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.olean", + "sha256": "3651d817386974e312357f20f0f5b695df32636b45ad87bf257e12333522f7de" + }, + "Lean.Elab.PreDefinition.PartialFixpoint": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint.olean", + "sha256": "e66825e384ff17dc6519d4c3bbb1e2d437fb9d06ccd62c25ae39462160bb8a74" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.olean", + "sha256": "dfaf14ede280a406724d7388dfd50253eb1f72bc95053c73e5b5ec562eb13181" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Induction": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.olean", + "sha256": "ace8bf806b6e3c115ca8dca8903b2590944121d6ee15b166a9e90d26f8c65de2" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.olean", + "sha256": "ce6f69f8a60fbf4529c56fb9d180b9848c4dc94b0924669d52edadea1eea85da" + }, + "Lean.Elab.PreDefinition.Structural": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural.olean", + "sha256": "5df5e860a2941222d125302b6992dfee99076a8dfe7635e03d0067b1de52037b" + }, + "Lean.Elab.PreDefinition.Structural.BRecOn": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/BRecOn.olean", + "sha256": "43d778c2e31237bab4927df047f983f90d8e51f0c8994766eade48f3cf6ac721" + }, + "Lean.Elab.PreDefinition.Structural.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Basic.olean", + "sha256": "b9c232de8b46027f3e53de76dcd73a120fe39c3d59967a5a5d4b770687546ff6" + }, + "Lean.Elab.PreDefinition.Structural.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Eqns.olean", + "sha256": "1ab842d0ec3f072b7ef36c3c389106b6281772e9c39077183524e8a7b2df26d4" + }, + "Lean.Elab.PreDefinition.Structural.FindRecArg": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.olean", + "sha256": "22c836971360cfbae10b952afc57c8cceea7c6e0776bc4f5785db9f56231f4dc" + }, + "Lean.Elab.PreDefinition.Structural.IndGroupInfo": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.olean", + "sha256": "bcbc74eedc2f318a8b2b3f67dee27bbad4499edf1b90e1b5ef2f97392829471e" + }, + "Lean.Elab.PreDefinition.Structural.IndPred": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndPred.olean", + "sha256": "933c5f3adb300c234bc4b21c33ac88720ce348df0da6101f5e29e82e2c9ebd09" + }, + "Lean.Elab.PreDefinition.Structural.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Main.olean", + "sha256": "c4239a1efe6ae90a63a33c58a2a4416ad6811c5b137a4fff5e14dea0c97dbf4e" + }, + "Lean.Elab.PreDefinition.Structural.Preprocess": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Preprocess.olean", + "sha256": "da41c20561ffeedc9fa735b40812cfc6f2019cb4ae039fcc9b50bdb3c4b42beb" + }, + "Lean.Elab.PreDefinition.Structural.RecArgInfo": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.olean", + "sha256": "374c899afb685ea073722e49bbec2c586e1a3f301580147f1092dce75749f0e9" + }, + "Lean.Elab.PreDefinition.Structural.SmartUnfolding": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.olean", + "sha256": "a3bb8c3544d361c4654090f576b2f089aca1931220817eadc9e6fde12d8d2e84" + }, + "Lean.Elab.PreDefinition.TerminationHint": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/TerminationHint.olean", + "sha256": "b008cd03dae9e9eb39f7c961783c7688bb0079c86b3380e5a2acba0931c96912" + }, + "Lean.Elab.PreDefinition.TerminationMeasure": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/TerminationMeasure.olean", + "sha256": "7b6a83a24610cdb1a23a9e279cc4e2490f0984dc226172227a54b14653bc04b5" + }, + "Lean.Elab.PreDefinition.WF": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF.olean", + "sha256": "d756a42673113d104a8f1f10ec8e5266fd550ab3307d74635cff1a79dfdf50ee" + }, + "Lean.Elab.PreDefinition.WF.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Basic.olean", + "sha256": "30e303f01dd11f5bfb9bfe9f0ac7281cb267c79ee600883e9b75ec7ef3269c4a" + }, + "Lean.Elab.PreDefinition.WF.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Eqns.olean", + "sha256": "cbcee84f0b521613f3b81a830c4672dcec0ec776d61e47ac8e8a6b323e9d8dda" + }, + "Lean.Elab.PreDefinition.WF.Fix": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Fix.olean", + "sha256": "1cd3b02dd48b1739fbdd069bca0f18019590476d52d0b55f770483952212ed4c" + }, + "Lean.Elab.PreDefinition.WF.FloatRecApp": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.olean", + "sha256": "2b2b7508f7f5f71d39f30b406dc2b24879727bee44615b1eabe341e1df9438e1" + }, + "Lean.Elab.PreDefinition.WF.GuessLex": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/GuessLex.olean", + "sha256": "193a0f7bb3f60de6c3af28362ca4e34e9e5812f17dc23e55e448a949992f31df" + }, + "Lean.Elab.PreDefinition.WF.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Main.olean", + "sha256": "f877b579eeead916865fd609fde94addce79bb845e0d983e5733a88485a5766c" + }, + "Lean.Elab.PreDefinition.WF.PackMutual": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/PackMutual.olean", + "sha256": "2a5db58f9cf338b84db997411fc33bfe8e86284d92310df8c5de6e0b4319267f" + }, + "Lean.Elab.PreDefinition.WF.Preprocess": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Preprocess.olean", + "sha256": "1c2bd7a90e2254ed6d603023a49e6171f7c0d9a14b5516b28a4c216f5006fea9" + }, + "Lean.Elab.PreDefinition.WF.Rel": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Rel.olean", + "sha256": "c5bc9c3e5ac6b953c20efa66eb36629b6b957e1b043e34c4bc970e0c86aa0c11" + }, + "Lean.Elab.PreDefinition.WF.Unfold": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Unfold.olean", + "sha256": "e6f3e0b9a8ac077b6329df9ed9c09f78cd31e02841a3511420ee8e65d226bbe6" + }, + "Lean.Elab.Print": { + "relative_path": "lib/lean/Lean/Elab/Print.olean", + "sha256": "51e5f29b3d8074b0a7162eff78b664217a5dbc27efb76b145dbaea0c05c34a96" + }, + "Lean.Elab.Quotation": { + "relative_path": "lib/lean/Lean/Elab/Quotation.olean", + "sha256": "71b2f7b722ffcaeb09b2708d6bc5d6ff5cf1c17b12376699ea36d61f4b422eed" + }, + "Lean.Elab.Quotation.Precheck": { + "relative_path": "lib/lean/Lean/Elab/Quotation/Precheck.olean", + "sha256": "991a462e6701ed3ac0da579a5f9f2c7f7f666f3c9841eda19c86bb9576108653" + }, + "Lean.Elab.Quotation.Util": { + "relative_path": "lib/lean/Lean/Elab/Quotation/Util.olean", + "sha256": "f1eb03e06f604ef25245d13da5f6e5884e335fbb462b85cc25d2fddb1799a7fd" + }, + "Lean.Elab.RecAppSyntax": { + "relative_path": "lib/lean/Lean/Elab/RecAppSyntax.olean", + "sha256": "6abcf436c2719a2ec1d8bd634b141bc3276d0bf3e27e3cf005ea336fc9663bb7" + }, + "Lean.Elab.RecommendedSpelling": { + "relative_path": "lib/lean/Lean/Elab/RecommendedSpelling.olean", + "sha256": "9661fccfded1a3c1cfa6fd6ffb7d563b2884d98e4e644ab18eca9200cbebfab6" + }, + "Lean.Elab.SetOption": { + "relative_path": "lib/lean/Lean/Elab/SetOption.olean", + "sha256": "787c484587500ec3158e59ca10eebfea0af7d3083806a9471891821f6495a64d" + }, + "Lean.Elab.StructInst": { + "relative_path": "lib/lean/Lean/Elab/StructInst.olean", + "sha256": "47bb7c2c4610c8d54accb1bd6542626bb9d4b08e731135120c54cc9b9952abec" + }, + "Lean.Elab.Structure": { + "relative_path": "lib/lean/Lean/Elab/Structure.olean", + "sha256": "156b1283480708d45f2d4ccb21165c157b65fafa79490d678b5b221e6ee0b44e" + }, + "Lean.Elab.Syntax": { + "relative_path": "lib/lean/Lean/Elab/Syntax.olean", + "sha256": "6aad81137b009aa764c5d98639ee5fb600f0ce6fc27cdef1e073588a4c223986" + }, + "Lean.Elab.SyntheticMVars": { + "relative_path": "lib/lean/Lean/Elab/SyntheticMVars.olean", + "sha256": "765f17386784a6540f899b2af62be08e7b576a00a78f41584973b8fabf27d621" + }, + "Lean.Elab.Tactic": { + "relative_path": "lib/lean/Lean/Elab/Tactic.olean", + "sha256": "a8372c1c69001269930b6cbb4e881b9e8b593ac0d594e93ec7e6d361eaf3c368" + }, + "Lean.Elab.Tactic.AsAuxLemma": { + "relative_path": "lib/lean/Lean/Elab/Tactic/AsAuxLemma.olean", + "sha256": "3ab8861debb8b53d853057c0c66642079e60144679861402226630668939e906" + }, + "Lean.Elab.Tactic.BVDecide": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide.olean", + "sha256": "6736cf5da5943762151cf22c1342fc178f0f295bee9aeb7cf004c317aa45a07d" + }, + "Lean.Elab.Tactic.BVDecide.External": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/External.olean", + "sha256": "50fecaf48258db97412a2cafd593773db1dfa2339c681a31a4102f808b7a1327" + }, + "Lean.Elab.Tactic.BVDecide.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend.olean", + "sha256": "1336b674c40caf3ba24bb63e4b78ac58dee96d925c2fcc3036283109aaf823d0" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Attr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.olean", + "sha256": "7a316bf1617de928f47afdd80f6ca28befae2fe6ad6b96dac4b7e290360f579b" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVCheck": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.olean", + "sha256": "75b4d47160ec998fe08da4884247a1cea961fad7e19bf6357670f6f626d5f036" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.olean", + "sha256": "6557c91e5d2a05ba4a56c820828531dab370c1809771585e49a7b96a9a40ac75" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.olean", + "sha256": "2b22721a88841e65d1256e7d6b3a7132b26ff1197f1ca65e3be5a5eb21422d49" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.olean", + "sha256": "7f79411de643ca37c169708a76aa12321701070ad666f41c243b1c6df2f52e07" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.olean", + "sha256": "3fa0a32b34699ba1f97db7c29be8d8b88b47c47e52de12f6191d5e6327c613b4" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.olean", + "sha256": "a04f49452a90cab257db038fe0025d6e9b9f72ee3313a479b99fcac4ae1c8f13" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.olean", + "sha256": "6c4ff9969869b0ba86b098d8bb95e2caeb88bc61426a7659ec2d1e80fd3f0496" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.olean", + "sha256": "65491bfa39b0698c310a8a8878cb01596e4616627416f40ae45e0fd622709e54" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.olean", + "sha256": "980164e9c31b64c83e46c01e78ec64630226c39920485143be4e40b859da161e" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVTrace": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.olean", + "sha256": "1996eabaa1c3f4916f484b35c39a4bcc270e9a46b9592b9b6e63b28b95acd5fa" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.LRAT": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.olean", + "sha256": "a9777f4dc66bea0b57d7a9b2b750ce78d906d0bfa930cfd0b0281b5920467aba" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.olean", + "sha256": "74af1f202de4c2fbe0aeab11e5bf05bb495342404062a0db74097f35b666b423" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.olean", + "sha256": "b24d88b0fbed216dfdaf934f8653d37291af5e1288d5485736bfd75deb10c182" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.olean", + "sha256": "df98785c5e1b7e6e5114b0c1a90760ee11277742f3ec36f4834cafa51fc567a1" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.olean", + "sha256": "8abb3b652bdd68df142259c20a7e85e26fc1c7f1ad5d1111ad8574cb7251323f" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.olean", + "sha256": "07d568115382b9a9832437443a5665dd9ab05ebaaa6e613e2336083a18a5f843" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.olean", + "sha256": "5a338a9edef0294acf2e8ee6923e0b02965595576fff7b130ced1626af66fdc6" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.olean", + "sha256": "b999e4ddc8d0d2077c56af1f1a000fe53fa3e81c97b47c5bf48d4dfbc243cfd8" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.olean", + "sha256": "82d5b4e7c2ec35f28230ce0ea464680a38a439260496c2ecc624130c7177a14b" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.olean", + "sha256": "bf6a3b70f9fedd5c42111b2afd4a947fc8085947342a1123073f65558540f436" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.olean", + "sha256": "a6588498df687fb758121463de9ae1040535ceb6c317715218669e061b05a088" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.olean", + "sha256": "87a5d15e22301b1a7c50064a06e11cae3e2b3b7ae8f4db72437bd5dea8d09077" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.olean", + "sha256": "7e18d7f9c1daff3a8b7eeca9765a3933fb244156bb5a238b03fd3d6667146a57" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.olean", + "sha256": "a60b02e2a039134f7b533c911f7beed13d84812b6062b9f19185630e282912ce" + }, + "Lean.Elab.Tactic.BVDecide.LRAT": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT.olean", + "sha256": "2265489cbaad7404d01662160bc49c6036f770a8a23257ad912587b3c94c992f" + }, + "Lean.Elab.Tactic.BVDecide.LRAT.Trim": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.olean", + "sha256": "496f7c3dd081cece59390406bd9ca3d7b8280aa923e7d50e764867b0f3895546" + }, + "Lean.Elab.Tactic.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Basic.olean", + "sha256": "b7c0301d5608f70cc3b200a6c051173f74f9feffb83b1e7993b680a28e4dec4f" + }, + "Lean.Elab.Tactic.BoolToPropSimps": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BoolToPropSimps.olean", + "sha256": "d5e4ca3bfddbd7e2538e80f41161ea63be1ed1eec0bd637d064b11e4478c6737" + }, + "Lean.Elab.Tactic.BuiltinTactic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BuiltinTactic.olean", + "sha256": "72d1c873432fe4f9dff0aa9a83056dd824703fe0faa8593f5e2a186335e12c21" + }, + "Lean.Elab.Tactic.Calc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Calc.olean", + "sha256": "b22ed20091a768b533dbf3cb92b94e3dea2a22cc70e6e013bc0e932c0a92d721" + }, + "Lean.Elab.Tactic.Change": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Change.olean", + "sha256": "c3d3fe5640183577289c4f0c7dfc9a5e82953709dc9f81ab3305a64f2c972f83" + }, + "Lean.Elab.Tactic.Classical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Classical.olean", + "sha256": "dd96a577b5982c72e7c2f9cce5cf089a933ecc0614589fdd0d741b39c721b9d5" + }, + "Lean.Elab.Tactic.Config": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Config.olean", + "sha256": "18f6104d6c843452c5742a476d16659ee05d21021eefd2d72d3a9be27a4c0009" + }, + "Lean.Elab.Tactic.Congr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Congr.olean", + "sha256": "c2cbd01a116eeab3bc6d560d5b5e812915eda68ddd4fd972444df910e1ce6f07" + }, + "Lean.Elab.Tactic.Conv": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv.olean", + "sha256": "9e13c60aac36d8d5ab077fb214f9749bd03e689fd47b66fdeb65f54b42e61fcc" + }, + "Lean.Elab.Tactic.Conv.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Basic.olean", + "sha256": "36acbc413b0baecc6d1db794fdf6e9afdc393dbb0a43b4d132ed06e80af8987d" + }, + "Lean.Elab.Tactic.Conv.Change": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Change.olean", + "sha256": "d6645dd05e52922f9008332cc16dffd5e475221c524292446010a022f7180efc" + }, + "Lean.Elab.Tactic.Conv.Congr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Congr.olean", + "sha256": "b5c476623ea1b622800815da4f1d2b769643c1bdb0c4c7524bed4851276413bf" + }, + "Lean.Elab.Tactic.Conv.Delta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Delta.olean", + "sha256": "6953c32bc540eaaa79b2221b31a9eecf9d86fc5ce46e69cc8f0ad6a3f1902419" + }, + "Lean.Elab.Tactic.Conv.Pattern": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Pattern.olean", + "sha256": "8fae7911921a66098eba444b60030314b9f52f202353e586205472afdd07c068" + }, + "Lean.Elab.Tactic.Conv.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Rewrite.olean", + "sha256": "492425f642d76075007692216a7368c533ebb8e0def54334a7fbbe849baed77e" + }, + "Lean.Elab.Tactic.Conv.Simp": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Simp.olean", + "sha256": "914f50cab77467b8faa5d21c14664fa552ca6c69339ecfc798150b48b37d3272" + }, + "Lean.Elab.Tactic.Conv.Unfold": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Unfold.olean", + "sha256": "a893adf2f22bb0bae62f47d5c4b30ae3bcedc121a7ab747398e5f780262be63b" + }, + "Lean.Elab.Tactic.Delta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Delta.olean", + "sha256": "c80c125f4b2c716c5a140a18b02d0c2c2add3d4a4e749e9774b6e36a6e6d726f" + }, + "Lean.Elab.Tactic.DiscrTreeKey": { + "relative_path": "lib/lean/Lean/Elab/Tactic/DiscrTreeKey.olean", + "sha256": "90696c26393713d01d2efefc91713c23de2d2b9ea842dcd5b0be7602ef2d2d51" + }, + "Lean.Elab.Tactic.Doc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Doc.olean", + "sha256": "f7466ce696081046b90259ed10bfce6647f3e31b5b624987527aace912d6836d" + }, + "Lean.Elab.Tactic.ElabTerm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ElabTerm.olean", + "sha256": "c93025d17c141b6a8172abd80d25fd2083f061aea574ed5b5fb85752f32ef39f" + }, + "Lean.Elab.Tactic.ExposeNames": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ExposeNames.olean", + "sha256": "b5083e8a6aa77fd5d2aa2a73cdd0777e2f2e7018e6fe73f017e31220f136ab36" + }, + "Lean.Elab.Tactic.Ext": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Ext.olean", + "sha256": "41b7e7b7c44fec4c25d21754296cb2c63b901f6ec840e4d68fd5f73c0d27bf16" + }, + "Lean.Elab.Tactic.FalseOrByContra": { + "relative_path": "lib/lean/Lean/Elab/Tactic/FalseOrByContra.olean", + "sha256": "e9c4388c61790ea040377ad4794524db4078ac279c84bfda4873f93a9e286e72" + }, + "Lean.Elab.Tactic.Generalize": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Generalize.olean", + "sha256": "f508333fab3030de8fd72a5d3e269baab671664d61c9a4f9d838a86a49945533" + }, + "Lean.Elab.Tactic.Grind": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Grind.olean", + "sha256": "08be616fb5e448a7109ff7ea58dd14de1902dbe5e8df8a873ba79e4e34523c74" + }, + "Lean.Elab.Tactic.Guard": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Guard.olean", + "sha256": "f853574192c0c04c7a6fd40a04e71966bea87d164c2dfd58066119d2b273cc53" + }, + "Lean.Elab.Tactic.Induction": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Induction.olean", + "sha256": "cb71a7fa68a672ebb2f3bfa1643a418d82d0c545d5d5b2e992a46695a14f491e" + }, + "Lean.Elab.Tactic.Injection": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Injection.olean", + "sha256": "a21d54f553d5ecbeb0bb2983f5d37040186dca297ccaa8fe5457c15333f55662" + }, + "Lean.Elab.Tactic.LibrarySearch": { + "relative_path": "lib/lean/Lean/Elab/Tactic/LibrarySearch.olean", + "sha256": "aa4345322004c2831a322f51f0b28e6c846017c08fe3dc2861c6497dca393055" + }, + "Lean.Elab.Tactic.Location": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Location.olean", + "sha256": "1098b443df5ebadfee2fc68faf7038dabacb07541f38639ac31be344e1391bdf" + }, + "Lean.Elab.Tactic.Match": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Match.olean", + "sha256": "63335a98a881cb68e20bffdb30fa3771ecb62823849ae21bb31426adc5aaccc9" + }, + "Lean.Elab.Tactic.Meta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Meta.olean", + "sha256": "567713a64ca01f5b9ab6c091ed9cd25f3ae811dd96d379690824c1048238a466" + }, + "Lean.Elab.Tactic.Monotonicity": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Monotonicity.olean", + "sha256": "fa4e39f81c52c25684740ec8b522ddb1e75e2a770da086aa498542a0254bb3ab" + }, + "Lean.Elab.Tactic.NormCast": { + "relative_path": "lib/lean/Lean/Elab/Tactic/NormCast.olean", + "sha256": "8edb153050da1e5977675c29d0faa559f8ede051b8384ea592aa05c9c892e10d" + }, + "Lean.Elab.Tactic.Omega": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega.olean", + "sha256": "4b2613345cb64b57ac4f8a0183f43e1afe4138ef8eaed2158e9d053107262491" + }, + "Lean.Elab.Tactic.Omega.Core": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/Core.olean", + "sha256": "f133556a6f4675885619fb6fb25a670fb3afce9a98b14ab0b31d89b5ecb6a2ea" + }, + "Lean.Elab.Tactic.Omega.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/Frontend.olean", + "sha256": "03c91bedf7a6187e5e74519f66bda5d6e18552fa291f950f9d3310613d99013d" + }, + "Lean.Elab.Tactic.Omega.MinNatAbs": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/MinNatAbs.olean", + "sha256": "5fc208621322f361f7d3e75f63418aec5d8851c6b75bd6a39e922f0d8b0ba191" + }, + "Lean.Elab.Tactic.Omega.OmegaM": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/OmegaM.olean", + "sha256": "99de653d54903f4599f5883f5fc1fb078ca24550ff5656b10ff227552f8af2b8" + }, + "Lean.Elab.Tactic.RCases": { + "relative_path": "lib/lean/Lean/Elab/Tactic/RCases.olean", + "sha256": "cb15fe0c2bb64023666293bb14cd157c6d756fa59dc0e8aec39b8b6f28968731" + }, + "Lean.Elab.Tactic.Repeat": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Repeat.olean", + "sha256": "5f1389c2109470e537d2486218baea2f9b69842ad86150b3c78d919b589020b5" + }, + "Lean.Elab.Tactic.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rewrite.olean", + "sha256": "332ab3fca4f37076f27bbdf57e5d614923d0d1048e1e325c56a4ae5f78a3bdf0" + }, + "Lean.Elab.Tactic.Rewrites": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rewrites.olean", + "sha256": "510a661f998f5c279f14b60fec476368bb1ed9a003c3c4753c6caa2d88c349c1" + }, + "Lean.Elab.Tactic.Rfl": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rfl.olean", + "sha256": "debc83c10ccd0f91e6944c7f2409f0390766d3c90195d90b9bc3e379a5528ebf" + }, + "Lean.Elab.Tactic.ShowTerm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ShowTerm.olean", + "sha256": "1a58d3dab98f084c1e30cd1ad363f9dcce132dd3563f7f1b3a10ea4e5b982b31" + }, + "Lean.Elab.Tactic.Simp": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simp.olean", + "sha256": "7c99ed2d7fd716baaff7454c392df88cc0ed62c7717f7a3df5fde04e69b76a24" + }, + "Lean.Elab.Tactic.SimpArith": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SimpArith.olean", + "sha256": "947ba620a7f12f3039363f12e8b609b1532421e0a15de3091c7476f38200cd19" + }, + "Lean.Elab.Tactic.SimpTrace": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SimpTrace.olean", + "sha256": "71135cbb56c87c91b4654fc258dfee3c56abd5659705c75502c97bc4098f2b1b" + }, + "Lean.Elab.Tactic.Simpa": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simpa.olean", + "sha256": "ecf16470fb1388ccc43ef450a7cc9a3bea94c691d800f90b909817b14d277db2" + }, + "Lean.Elab.Tactic.Simproc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simproc.olean", + "sha256": "67adccf068a87d29a3658b600ea8d395ad93eb34518f94930e273e9dd227a998" + }, + "Lean.Elab.Tactic.SolveByElim": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SolveByElim.olean", + "sha256": "4b83ef14834e716e40e4225b7fc6e6e0be6a4fac044490fcdcea8684314e9890" + }, + "Lean.Elab.Tactic.Split": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Split.olean", + "sha256": "1d662891823face6895782eadc704cb76813e37325f70c681ac2e481219d06a2" + }, + "Lean.Elab.Tactic.Symm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Symm.olean", + "sha256": "03415c9848515aa79dac3634eda5a005dbe2d662168206bdae2d4aeebbc5c670" + }, + "Lean.Elab.Tactic.TreeTacAttr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/TreeTacAttr.olean", + "sha256": "317645bd9832a71c3d83747c516f0084c6f778a2f01a9f1725396a9ee99f9405" + }, + "Lean.Elab.Tactic.Try": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Try.olean", + "sha256": "e06377c171ef6f8d33196b70e2c138672956f14a668924bd8dbba6ede2325966" + }, + "Lean.Elab.Tactic.Unfold": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Unfold.olean", + "sha256": "a096a399bfc253d22fceda76ad31bfe1c32923302d3fc517e0736b8c2e29fb74" + }, + "Lean.Elab.Term": { + "relative_path": "lib/lean/Lean/Elab/Term.olean", + "sha256": "f96c6c457c651da44cb9aed7d0af002589a9dd635ec492029254eeb679e85703" + }, + "Lean.Elab.Time": { + "relative_path": "lib/lean/Lean/Elab/Time.olean", + "sha256": "6b9da11286e522cb54d1759a5e4f93f50dc49b537c785daca8362c216c0141ef" + }, + "Lean.Elab.Util": { + "relative_path": "lib/lean/Lean/Elab/Util.olean", + "sha256": "d17dd23eb1ff8167dfe81c18ca2d79eb2aa863ad660be8f91057f952ac60ec2e" + }, + "Lean.Environment": { + "relative_path": "lib/lean/Lean/Environment.olean", + "sha256": "f65e86963b340104aec0500759c0221ce805877552a74a222444517efea4f327" + }, + "Lean.Exception": { + "relative_path": "lib/lean/Lean/Exception.olean", + "sha256": "348180c98395bf5936594ac1a00295baf447f096c9d55de58f1ad28b80ff532e" + }, + "Lean.Expr": { + "relative_path": "lib/lean/Lean/Expr.olean", + "sha256": "b109611aabeef2b002d78f15e7d05934c7af1dc5739a2aadde294f1417e828ee" + }, + "Lean.HeadIndex": { + "relative_path": "lib/lean/Lean/HeadIndex.olean", + "sha256": "a184c76eed310d6d6e6a855f50d25e694c10a0f3be2c8c2e01aafa23113aa817" + }, + "Lean.Hygiene": { + "relative_path": "lib/lean/Lean/Hygiene.olean", + "sha256": "f8122bf1f713f1514bdbdeb3cee8090c7d524255998bdb3f077a26fbf9e33bb9" + }, + "Lean.ImportingFlag": { + "relative_path": "lib/lean/Lean/ImportingFlag.olean", + "sha256": "ce6df3c54e60e9f9741b44b6c787667ff8edea324d61df14d97c3c6be2d4a314" + }, + "Lean.InternalExceptionId": { + "relative_path": "lib/lean/Lean/InternalExceptionId.olean", + "sha256": "314fb4e2c9c8a74700fb4ba28ff8996102d6960b101dc5e8ea058928b76671e7" + }, + "Lean.KeyedDeclsAttribute": { + "relative_path": "lib/lean/Lean/KeyedDeclsAttribute.olean", + "sha256": "6965a89059d292ffd11ede6d477a9895b5742df767da760a63958167e08709da" + }, + "Lean.LabelAttribute": { + "relative_path": "lib/lean/Lean/LabelAttribute.olean", + "sha256": "f6357ee28525c80e0e1e50f30d6abc8e9c212faf66266638907f7734baf8c4a9" + }, + "Lean.Language.Basic": { + "relative_path": "lib/lean/Lean/Language/Basic.olean", + "sha256": "116198598d0a090a3f8c1ac2df76863e2c130506768f741dd96c657b4f28f62c" + }, + "Lean.Language.Lean": { + "relative_path": "lib/lean/Lean/Language/Lean.olean", + "sha256": "ec21c3356101da99d833c4dbe27da14a587b238e0dcfead17dd1954358b4e730" + }, + "Lean.Language.Lean.Types": { + "relative_path": "lib/lean/Lean/Language/Lean/Types.olean", + "sha256": "e41961572ed5c15c53ca9829747714c5157397631bd11805558205cc21d2c300" + }, + "Lean.Language.Util": { + "relative_path": "lib/lean/Lean/Language/Util.olean", + "sha256": "7a02b960729bb110fe366fa1cfc75e7974ed6c4e984488b3d41c3701bae6d021" + }, + "Lean.Level": { + "relative_path": "lib/lean/Lean/Level.olean", + "sha256": "b0a2bdff71bacb1202f1c2b034fbfcaef3a928cb8508fe31751111872644168f" + }, + "Lean.Linter": { + "relative_path": "lib/lean/Lean/Linter.olean", + "sha256": "0ad71e4ddd414f842de88817808764b12d0dbc35fb0250beb219a6aac4d105e1" + }, + "Lean.Linter.Basic": { + "relative_path": "lib/lean/Lean/Linter/Basic.olean", + "sha256": "f15c89429080e69fa9ce443c7ab1462990d6cfb127c38ce3cc2e9c3150eaf319" + }, + "Lean.Linter.Builtin": { + "relative_path": "lib/lean/Lean/Linter/Builtin.olean", + "sha256": "65bcaf73e26b3b782cc55118edee888ef878f6eb321ef6c89ba6344c8c828727" + }, + "Lean.Linter.ConstructorAsVariable": { + "relative_path": "lib/lean/Lean/Linter/ConstructorAsVariable.olean", + "sha256": "d23b80487fc0b4ffb80cfe74517b2b44c317f857288c45e9573fa5595e7c0b76" + }, + "Lean.Linter.Deprecated": { + "relative_path": "lib/lean/Lean/Linter/Deprecated.olean", + "sha256": "ee83025c6435587e7822db2d39a94f7192a3be4828e76712936a6d687c1654b5" + }, + "Lean.Linter.List": { + "relative_path": "lib/lean/Lean/Linter/List.olean", + "sha256": "72b11db674930f01297e66d6fe9168b2711db7ed0f3a8062014bbe5628431447" + }, + "Lean.Linter.MissingDocs": { + "relative_path": "lib/lean/Lean/Linter/MissingDocs.olean", + "sha256": "89abae84ca6318a0f514ad6ab9164a28db6a35afe87b77303fca87d4a725dcff" + }, + "Lean.Linter.Omit": { + "relative_path": "lib/lean/Lean/Linter/Omit.olean", + "sha256": "8e0d622b1be4f992d2355f4ec978f33899e36c6caaeca50b3394326f74cab35e" + }, + "Lean.Linter.UnusedVariables": { + "relative_path": "lib/lean/Lean/Linter/UnusedVariables.olean", + "sha256": "d5bae599fc34fe808ea8d61cefa05405ae98d97184c208c92cbe883e9dfc20ea" + }, + "Lean.Linter.Util": { + "relative_path": "lib/lean/Lean/Linter/Util.olean", + "sha256": "e983ec22a68494993b52d4bc349e4fd8ed0e73c11a7236cdcfd14c58058da4a3" + }, + "Lean.LoadDynlib": { + "relative_path": "lib/lean/Lean/LoadDynlib.olean", + "sha256": "7bbb1aa363e257a2de2975ac17e31bbf58d4d4cd328d592710e6a718e71496b4" + }, + "Lean.LocalContext": { + "relative_path": "lib/lean/Lean/LocalContext.olean", + "sha256": "1b6191a3341ed46fa6b8dbcd3f24e245ae1b8c6ab39d080f2ff5cecc2e26250e" + }, + "Lean.Log": { + "relative_path": "lib/lean/Lean/Log.olean", + "sha256": "032fbe05a131072d1b0779947f012b10687e42ee07019d7ea29fff2d100e709f" + }, + "Lean.Message": { + "relative_path": "lib/lean/Lean/Message.olean", + "sha256": "c36f1a3906e9d18d564572f38bd3b687db02b21897db07f6470025ae522ea73f" + }, + "Lean.Meta": { + "relative_path": "lib/lean/Lean/Meta.olean", + "sha256": "206cf2fcc5bef1191f930198dfb2b0cd2042bf96f47c40faaf98cc105e137809" + }, + "Lean.Meta.ACLt": { + "relative_path": "lib/lean/Lean/Meta/ACLt.olean", + "sha256": "da1c2e3e8f486413a1fee34f34a938179cfdd72342ced421b82d230af508788d" + }, + "Lean.Meta.AbstractMVars": { + "relative_path": "lib/lean/Lean/Meta/AbstractMVars.olean", + "sha256": "a3e0a762ba6c0f8852c50c993c98208b5ce37e53cd374530f2b6f2cd119a4b34" + }, + "Lean.Meta.AbstractNestedProofs": { + "relative_path": "lib/lean/Lean/Meta/AbstractNestedProofs.olean", + "sha256": "fc0a2ed4ddd5bfc2c16958b017a88d2751126cec190d0eeb80a777c6825d2fa4" + }, + "Lean.Meta.AppBuilder": { + "relative_path": "lib/lean/Lean/Meta/AppBuilder.olean", + "sha256": "7cd2bf696029e7211829c3c8152df760b2e4695304ca409a76775c196ae56549" + }, + "Lean.Meta.ArgsPacker": { + "relative_path": "lib/lean/Lean/Meta/ArgsPacker.olean", + "sha256": "a7f9e66a5cc17f1ce38ec0b459f0ca4ab7b8a4273762e2c05b35ad57626b539e" + }, + "Lean.Meta.ArgsPacker.Basic": { + "relative_path": "lib/lean/Lean/Meta/ArgsPacker/Basic.olean", + "sha256": "6d74b8180f4fbc25df85bd09ae4ff159591fd5b7ec68dc02b798cb70a79112e4" + }, + "Lean.Meta.Basic": { + "relative_path": "lib/lean/Lean/Meta/Basic.olean", + "sha256": "f12db9629e0a571e3774816fec958dbc481f79f7b8a2c4c4bbd5208e12ccc24d" + }, + "Lean.Meta.BinderNameHint": { + "relative_path": "lib/lean/Lean/Meta/BinderNameHint.olean", + "sha256": "0d948af6513e8326ed601ea521ff00b87dd6d019bd5b60bf40860a7e5f5905f8" + }, + "Lean.Meta.Canonicalizer": { + "relative_path": "lib/lean/Lean/Meta/Canonicalizer.olean", + "sha256": "9262985c3ac4e2f8b7207fdeb2bf7fbab1db0dc6581b85a26c2cc27965ec43ee" + }, + "Lean.Meta.Check": { + "relative_path": "lib/lean/Lean/Meta/Check.olean", + "sha256": "502569420ced0ae9c7c72746fe0a34b7340279a7852e922a9b8ec5c183b97235" + }, + "Lean.Meta.CheckTactic": { + "relative_path": "lib/lean/Lean/Meta/CheckTactic.olean", + "sha256": "30e7beace22600567ab8f275bda3c48c83d8d80a14a654a0f723e125eef28377" + }, + "Lean.Meta.Closure": { + "relative_path": "lib/lean/Lean/Meta/Closure.olean", + "sha256": "092e59d5c44691e648c7e6b4151d18030b17a703b124d134c3e233d952c90058" + }, + "Lean.Meta.Coe": { + "relative_path": "lib/lean/Lean/Meta/Coe.olean", + "sha256": "72cd74ba7424353c0c7acb6cd05dd27d7f27d07fa8936fd54a96141d22d7671c" + }, + "Lean.Meta.CoeAttr": { + "relative_path": "lib/lean/Lean/Meta/CoeAttr.olean", + "sha256": "16993537a5507a03ac41462d5a54030993c6e9303353d59270b5df4762af31a9" + }, + "Lean.Meta.CollectFVars": { + "relative_path": "lib/lean/Lean/Meta/CollectFVars.olean", + "sha256": "d46e2325951ddff2997f5d37f9b688edc09d75d360711d9ae51415b9ed6a6dde" + }, + "Lean.Meta.CollectMVars": { + "relative_path": "lib/lean/Lean/Meta/CollectMVars.olean", + "sha256": "b2846166247972427c1225d20859aaa46fe676c321f3e4b8943ae064d9259b1e" + }, + "Lean.Meta.CompletionName": { + "relative_path": "lib/lean/Lean/Meta/CompletionName.olean", + "sha256": "2af094a0fd892457002a8b311a318ebb1d3b347f694fa5bd3c4a710bb3d0f5ae" + }, + "Lean.Meta.CongrTheorems": { + "relative_path": "lib/lean/Lean/Meta/CongrTheorems.olean", + "sha256": "ae1d73989795378f2db8d6725484544fbf700d26861669e26ed071fb3d5aa774" + }, + "Lean.Meta.Constructions": { + "relative_path": "lib/lean/Lean/Meta/Constructions.olean", + "sha256": "bd42abcf4b09dd47d7b07f34bce755794a76f242171f34720060f743c91d7e7b" + }, + "Lean.Meta.Constructions.BRecOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/BRecOn.olean", + "sha256": "91bb12647e28558fa3562e3ef84df4f40044d7a68fa2d0a0092f9a8b52852111" + }, + "Lean.Meta.Constructions.CasesOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/CasesOn.olean", + "sha256": "827e45d478f86cf087cc904ee3c3021343ac62fcf500ced79f733a631a72c4c8" + }, + "Lean.Meta.Constructions.NoConfusion": { + "relative_path": "lib/lean/Lean/Meta/Constructions/NoConfusion.olean", + "sha256": "4428b1ecf05f66c20cbfd068963aa5778bb1dc417f84e24a99010e93618d9268" + }, + "Lean.Meta.Constructions.RecOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/RecOn.olean", + "sha256": "08d7bf9cce44bfb9da0382e248b7232936f8e9b4e04d9f01272257e2c3e93e58" + }, + "Lean.Meta.CtorRecognizer": { + "relative_path": "lib/lean/Lean/Meta/CtorRecognizer.olean", + "sha256": "dc104bc4378dcd0427c4d67654ad199261907c9434bd5e59548f1960b7918c57" + }, + "Lean.Meta.DecLevel": { + "relative_path": "lib/lean/Lean/Meta/DecLevel.olean", + "sha256": "a2eed500e45408ea6f1531256849e4e47d7cb3ccdb8621c3a44769f45d23d37a" + }, + "Lean.Meta.Diagnostics": { + "relative_path": "lib/lean/Lean/Meta/Diagnostics.olean", + "sha256": "e64e866f33cb55305ffb4588647652a034aa08108bda8e49ba7b87f5b5c09dc8" + }, + "Lean.Meta.DiscrTree": { + "relative_path": "lib/lean/Lean/Meta/DiscrTree.olean", + "sha256": "a285696f66951a789b2d325baec39c256f247a40c4c442dcc5b5c631185a590e" + }, + "Lean.Meta.DiscrTreeTypes": { + "relative_path": "lib/lean/Lean/Meta/DiscrTreeTypes.olean", + "sha256": "35157be01b47d45c6ccfb978fe042752d42b919a13c2c59df749d78df28513d1" + }, + "Lean.Meta.Eqns": { + "relative_path": "lib/lean/Lean/Meta/Eqns.olean", + "sha256": "61d27ab1c2d1ea8db95324a4612e717c5e0a8c9fd7e6bb7cb13c928f4cc63703" + }, + "Lean.Meta.Eval": { + "relative_path": "lib/lean/Lean/Meta/Eval.olean", + "sha256": "8451e897121ce84e0e443be0ad1de1177143a1960c634d31c1b373d0ec30e5a1" + }, + "Lean.Meta.ExprDefEq": { + "relative_path": "lib/lean/Lean/Meta/ExprDefEq.olean", + "sha256": "ac84eb17f56223f5cf46553327dbfa0279b437802957cb292551c592b449a502" + }, + "Lean.Meta.ExprLens": { + "relative_path": "lib/lean/Lean/Meta/ExprLens.olean", + "sha256": "b8ac1969551532255d7a2b0223a00c65bf0bc468f90e7aba64fd6c697db6bb5b" + }, + "Lean.Meta.ExprTraverse": { + "relative_path": "lib/lean/Lean/Meta/ExprTraverse.olean", + "sha256": "b0cf3399e8837d8019f29b7e42b94028b42c6fcf40bca98a498ee9a3641ff948" + }, + "Lean.Meta.ForEachExpr": { + "relative_path": "lib/lean/Lean/Meta/ForEachExpr.olean", + "sha256": "6f2ade443619ee7d60f73bc62b4e1efd7372418d4f5b28b8b8233ac2c28ce1a9" + }, + "Lean.Meta.FunInfo": { + "relative_path": "lib/lean/Lean/Meta/FunInfo.olean", + "sha256": "b855ba9c1d30fec86c39339dd3cbfef0cfcdcdb7e78c25ad04103b37abc1a9ca" + }, + "Lean.Meta.GeneralizeTelescope": { + "relative_path": "lib/lean/Lean/Meta/GeneralizeTelescope.olean", + "sha256": "5ee0c1c92441c434c043593778ed21e47badeadce84e78a99682cedfad480372" + }, + "Lean.Meta.GeneralizeVars": { + "relative_path": "lib/lean/Lean/Meta/GeneralizeVars.olean", + "sha256": "796bc3bc0a297f547b39413e39611eb8829e642e7f44da2f4cea6d0d4ef56265" + }, + "Lean.Meta.GetUnfoldableConst": { + "relative_path": "lib/lean/Lean/Meta/GetUnfoldableConst.olean", + "sha256": "2ea066ddcc64d26c2d70e77bd3c7b015c8ee3f755d10187352eb155962d91427" + }, + "Lean.Meta.GlobalInstances": { + "relative_path": "lib/lean/Lean/Meta/GlobalInstances.olean", + "sha256": "8265fb3b50c621767dc77e38921e2fe7360694ce5b7ac3e24bdc67e0c3946f57" + }, + "Lean.Meta.IndPredBelow": { + "relative_path": "lib/lean/Lean/Meta/IndPredBelow.olean", + "sha256": "c93d1f840670b555e569ac9d262d1f41decd51f3d134d54ff4e53bb542e9cb58" + }, + "Lean.Meta.Inductive": { + "relative_path": "lib/lean/Lean/Meta/Inductive.olean", + "sha256": "cbd800e5e3644765969dc14c322b700120c9dd2c3db0d499e72c13f607fb29aa" + }, + "Lean.Meta.InferType": { + "relative_path": "lib/lean/Lean/Meta/InferType.olean", + "sha256": "a9e3c61dd6022e6864ca3416c5567360975a3781076d8dedd4b93507bfe12703" + }, + "Lean.Meta.Injective": { + "relative_path": "lib/lean/Lean/Meta/Injective.olean", + "sha256": "022f6530d2761e0fd32e4a8a1d390badfe3bbf852a92bebf2269b4cacf93ac9d" + }, + "Lean.Meta.Instances": { + "relative_path": "lib/lean/Lean/Meta/Instances.olean", + "sha256": "fcc360ddf8ee95db9d62118b0c262c6695b38251dcd96f086fee6c5195966516" + }, + "Lean.Meta.IntInstTesters": { + "relative_path": "lib/lean/Lean/Meta/IntInstTesters.olean", + "sha256": "33498b0c4626bd28ce45b7a3f7996aaee28f3cea1e8a9a6cbbe6fdeb24619209" + }, + "Lean.Meta.Iterator": { + "relative_path": "lib/lean/Lean/Meta/Iterator.olean", + "sha256": "101d4d68efea3a23fbd0dc5f16e63ff16c65b391862a09feee2f7930dc671703" + }, + "Lean.Meta.KAbstract": { + "relative_path": "lib/lean/Lean/Meta/KAbstract.olean", + "sha256": "1ff48dc21dc7daa5701ec93ebf8dea8e853eb9c76c7f08df3c047b2e364c0fd6" + }, + "Lean.Meta.KExprMap": { + "relative_path": "lib/lean/Lean/Meta/KExprMap.olean", + "sha256": "a61c80321e32eb1ac29c70f05a557bc9a950b6a65d0503e94031cd21c697f84c" + }, + "Lean.Meta.LazyDiscrTree": { + "relative_path": "lib/lean/Lean/Meta/LazyDiscrTree.olean", + "sha256": "0e52ab3e1bba285513237aa0ad00ebbeca9f6f2de5e6ffed01aa0aff4ebce915" + }, + "Lean.Meta.LevelDefEq": { + "relative_path": "lib/lean/Lean/Meta/LevelDefEq.olean", + "sha256": "039d6b9b7f252227092b329102542df7d9c09edceb1aefa45fc712078c65c5d7" + }, + "Lean.Meta.LitValues": { + "relative_path": "lib/lean/Lean/Meta/LitValues.olean", + "sha256": "fc41c863bde3e203433870eb601640349cb7855f816bdebbde1a2a204c9bdace" + }, + "Lean.Meta.Match": { + "relative_path": "lib/lean/Lean/Meta/Match.olean", + "sha256": "548ceb8925264b3c53204550bfea3548b9e73b11f0124d9a7f4343aed053ad9d" + }, + "Lean.Meta.Match.Basic": { + "relative_path": "lib/lean/Lean/Meta/Match/Basic.olean", + "sha256": "ad8f2a68e4366a7c0c5939323446515ac428595f1da113a506bf12039fb16442" + }, + "Lean.Meta.Match.CaseArraySizes": { + "relative_path": "lib/lean/Lean/Meta/Match/CaseArraySizes.olean", + "sha256": "e221018a693db011a0414635b7b68c8b8388950b2c2d4731ce41a6a5576a1d57" + }, + "Lean.Meta.Match.CaseValues": { + "relative_path": "lib/lean/Lean/Meta/Match/CaseValues.olean", + "sha256": "537ddad23a87967f7088967a2a347eb108cc36e2d4e4d9ffb0a8396d65da88df" + }, + "Lean.Meta.Match.Match": { + "relative_path": "lib/lean/Lean/Meta/Match/Match.olean", + "sha256": "2e73790b9ba9e908afaec1f9636dbe6f8ca5388dd11caa89f03e0e9579138516" + }, + "Lean.Meta.Match.MatchEqs": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchEqs.olean", + "sha256": "3e0c930d82985234eaf74ec74fb3bc7dffc959608f43bd38ac33a884500315a7" + }, + "Lean.Meta.Match.MatchEqsExt": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchEqsExt.olean", + "sha256": "bfe53903e9962eeede9b619f0ba796108662c4945af59198a5834799589b1d68" + }, + "Lean.Meta.Match.MatchPatternAttr": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchPatternAttr.olean", + "sha256": "6c7c6f96c64e483fc2864cb94a9e2f1fe2570e04660100eec221bb0511e5684a" + }, + "Lean.Meta.Match.MatcherApp": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp.olean", + "sha256": "e2ed9a86cbc2817d5fa9a023ef571b6b077e2626b8c4e6799fc4f9c31bfa9520" + }, + "Lean.Meta.Match.MatcherApp.Basic": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp/Basic.olean", + "sha256": "cd872e793052ffcbbdaed58e949e35afe056e7b7177b49c70d3c5fd6cb269825" + }, + "Lean.Meta.Match.MatcherApp.Transform": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp/Transform.olean", + "sha256": "df0e6ddff62c7c9906a8704ed1338b841299acbdb0c4894eea4dd9f253824cb4" + }, + "Lean.Meta.Match.MatcherInfo": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherInfo.olean", + "sha256": "83151f202d8e0d8b58fd86326458d33e3f8f060038aaccc7909d07cfb8c4a5c6" + }, + "Lean.Meta.Match.Value": { + "relative_path": "lib/lean/Lean/Meta/Match/Value.olean", + "sha256": "0c40eecc0e0da4ec9cc2eec21580f3493911fb56c753dab89c51327bfb64551a" + }, + "Lean.Meta.MatchUtil": { + "relative_path": "lib/lean/Lean/Meta/MatchUtil.olean", + "sha256": "5ff0623e662f1b1ba9035709de58345cf18417f05bf3580448d963471d4f1f93" + }, + "Lean.Meta.NatInstTesters": { + "relative_path": "lib/lean/Lean/Meta/NatInstTesters.olean", + "sha256": "3a54ef6c555c2304cd894a59b7519e7cf1138c5082ea7c6b541d2558f68d729e" + }, + "Lean.Meta.Offset": { + "relative_path": "lib/lean/Lean/Meta/Offset.olean", + "sha256": "e9bccfe44f2cb64ac53bdb8d4391720754a15706c982a7f4ee8b3c19b2001ed2" + }, + "Lean.Meta.PPGoal": { + "relative_path": "lib/lean/Lean/Meta/PPGoal.olean", + "sha256": "1ff4e4b1dd870a3fc09b5b9bd5bdf20dd4a0263d2a652b4d4d3461495e7d713b" + }, + "Lean.Meta.PProdN": { + "relative_path": "lib/lean/Lean/Meta/PProdN.olean", + "sha256": "d8b86b781fa66571ceb5087c16cac87cd37beb344e9134818bff6e4003f2a6b4" + }, + "Lean.Meta.RecursorInfo": { + "relative_path": "lib/lean/Lean/Meta/RecursorInfo.olean", + "sha256": "c7deca642d62ab08712aa143b716f781872a5e421470246d94bc9fb7dd862b47" + }, + "Lean.Meta.Reduce": { + "relative_path": "lib/lean/Lean/Meta/Reduce.olean", + "sha256": "6ae0326d4d14d180af14176daf097cf236bd4347a95d87b93a7e5996d1ae95ea" + }, + "Lean.Meta.ReduceEval": { + "relative_path": "lib/lean/Lean/Meta/ReduceEval.olean", + "sha256": "50aaeb5ac37fb6154b0e2c1c5d3085f3cf61736ec3b316ab2bd9e7d4d7babc40" + }, + "Lean.Meta.SizeOf": { + "relative_path": "lib/lean/Lean/Meta/SizeOf.olean", + "sha256": "af408b51fc723ab8bd677b7e5a84d33b6639d1e481b7f058d3e5f16200c7a5c5" + }, + "Lean.Meta.Sorry": { + "relative_path": "lib/lean/Lean/Meta/Sorry.olean", + "sha256": "56b4c84f52c8c7925b6c1a850fb91ff7d7966e113ed79a39e140ae46f5fde7a9" + }, + "Lean.Meta.Structure": { + "relative_path": "lib/lean/Lean/Meta/Structure.olean", + "sha256": "e5f9fa309279c95a5cf27878c316b302eba85e26b4aa1d6e85f5b43d6453616a" + }, + "Lean.Meta.SynthInstance": { + "relative_path": "lib/lean/Lean/Meta/SynthInstance.olean", + "sha256": "dc0a3b8ea0ef34849ba5ca57477fd5ccb37d7ccad92151d8b231f17afb86c5dd" + }, + "Lean.Meta.Tactic": { + "relative_path": "lib/lean/Lean/Meta/Tactic.olean", + "sha256": "ad4914ed10cf80c2d4a2388d6fb8af91cc2d2991c9475e8cab2eb6ba7d57ea22" + }, + "Lean.Meta.Tactic.AC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AC.olean", + "sha256": "ee57ccf20ad198b447ea1b6e0f7ceb4a6b3ae399b5dc45ca144164e7f41148fc" + }, + "Lean.Meta.Tactic.AC.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AC/Main.olean", + "sha256": "2bdbf30c5961d39ed784e11ba8bbbee10f34d882c8e515bfedfaae65c2983174" + }, + "Lean.Meta.Tactic.Acyclic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Acyclic.olean", + "sha256": "1d138ed59a13cdb5360dee24852ee3dcef4d97a3da34e175c3d5ba1a5afbfe98" + }, + "Lean.Meta.Tactic.Apply": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Apply.olean", + "sha256": "c1283b20feace19b65fc7e23af16221b8d0a14ac59dd7c70d8d0a83222e94baa" + }, + "Lean.Meta.Tactic.Assert": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Assert.olean", + "sha256": "7673647ca3e547e0078675263dc676f122d87c602266d432c78229cb716be2fe" + }, + "Lean.Meta.Tactic.Assumption": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Assumption.olean", + "sha256": "bbe1c2ac91bb85c39556a28690834034b3faff15ffa79f396f5646154597185b" + }, + "Lean.Meta.Tactic.AuxLemma": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AuxLemma.olean", + "sha256": "b621afecfc83539db089cf44ceee268d994ee0371559db2bafee8341ade61caa" + }, + "Lean.Meta.Tactic.Backtrack": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Backtrack.olean", + "sha256": "6ba89a26edd430b58166fa46607e7b7e7904172b1984de835b7eb9a584fec426" + }, + "Lean.Meta.Tactic.Cases": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Cases.olean", + "sha256": "f82be51283b6ca0a88b466e325061872da1ca78317d784222c2d4d5f095f25d9" + }, + "Lean.Meta.Tactic.Cleanup": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Cleanup.olean", + "sha256": "5daf92f058790a58da353d444701d231bc0d7ffac8ac7a641a396f71c09150d2" + }, + "Lean.Meta.Tactic.Clear": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Clear.olean", + "sha256": "829fa3bd204a603f0686f6060b474f98815ba786324b91fbf166c40783702c4b" + }, + "Lean.Meta.Tactic.Congr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Congr.olean", + "sha256": "2fe9a126baf313a410bca67c2ba600b5397776b3096845ca5bfd4c71f4065195" + }, + "Lean.Meta.Tactic.Constructor": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Constructor.olean", + "sha256": "867577fa39e8b883035764c3dc65017fdb335a365931aab74461676eb3d4ff43" + }, + "Lean.Meta.Tactic.Contradiction": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Contradiction.olean", + "sha256": "4f2fea4e956ca33f43b6958efcba64ec2f7da8199bf2e8305ea09dc0a9a387be" + }, + "Lean.Meta.Tactic.Delta": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Delta.olean", + "sha256": "b80e1e36a4f334d593cc5c2692020ccf113e0066cb9bccf59b88d706a1ed3303" + }, + "Lean.Meta.Tactic.ElimInfo": { + "relative_path": "lib/lean/Lean/Meta/Tactic/ElimInfo.olean", + "sha256": "59a71e16fbbfb5a22573b245e4d7068eee6d9b0d40b49602cdd03e0d4e9bdc5a" + }, + "Lean.Meta.Tactic.ExposeNames": { + "relative_path": "lib/lean/Lean/Meta/Tactic/ExposeNames.olean", + "sha256": "3b31fb2dba571938bce63170aadf82501c229ac457caad8427c58eef935ba444" + }, + "Lean.Meta.Tactic.Ext": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Ext.olean", + "sha256": "22bb0d168e310524c9788a3c415614b51ed048dbfd5a51652f46b0068c77b4a2" + }, + "Lean.Meta.Tactic.FVarSubst": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FVarSubst.olean", + "sha256": "8c21b3a5802e4d08978539b78c1dbb67508903b3f21978b38ef9cc57c270a27c" + }, + "Lean.Meta.Tactic.FunInd": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunInd.olean", + "sha256": "6296c74e67fb553b1bc764a5e07c2d5bbb6c4ebd3b323557c64d01267d1801ab" + }, + "Lean.Meta.Tactic.FunIndCollect": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunIndCollect.olean", + "sha256": "abb578a79335d722c9d69eef073a1ccb64c966b6b7dcdf501b9825181ea2165d" + }, + "Lean.Meta.Tactic.FunIndInfo": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunIndInfo.olean", + "sha256": "7fcea4ed90a733cf9b1d874e6c805f123f293da6379e4a658df2333f64cd5bc5" + }, + "Lean.Meta.Tactic.Generalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Generalize.olean", + "sha256": "c6b2a2530dbb3966ededa8eec4476801bc7c85e1a69c17519d2b47a6e3bb3047" + }, + "Lean.Meta.Tactic.Grind": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind.olean", + "sha256": "a4a04684e58d43aa05cb1c41eb3e18cf6af8da64c935a88fea4b41e394461a78" + }, + "Lean.Meta.Tactic.Grind.Arith": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith.olean", + "sha256": "3cb51d31133b73246d8131265dafb9cede95fc310dbe7bb4b5b7ece65b2598ad" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.olean", + "sha256": "dd481e2963c500cd4c4f686f800ae5d5ab818b1055fcd1cb95bab98516dbf96e" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.olean", + "sha256": "78cc1a489ac6c1dd48dbeae02db742ed4a0867263e877192ab4b417807b73251" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.olean", + "sha256": "bd0a7b837aeda3d44ba972c14219b3f8bf1fda4e68fa1b7b2a98b911007d6ae0" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.olean", + "sha256": "1e84cc67e9674371b9e1ee937f052ebaf33f949ee98fed97ae3e5a0af14ad8bc" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.olean", + "sha256": "bbaf4808f9bef4fd58cffdd9dbbebcaae4a275b740f912f4357bfcd71807dad1" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.olean", + "sha256": "bb82e33912900ffca9cb8b05ba27175bc5be751f59921b09f13322dff9997fdb" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.olean", + "sha256": "868752823c6951c957840f933609d6fe1dc86026fd810479862fdc3c73b84399" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.olean", + "sha256": "8092837e82e32858cfe423c1f20453c3c38a013c54abb05f872b1233cfbe8e5f" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.olean", + "sha256": "370a4249179e8a0d228121d74a22194b50afc23395fcc3d8024621527d703ac1" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.olean", + "sha256": "3c8f3c889d553bf6ef43ed0c444859e905cd162356ce04f85247b0456a4f7b4e" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Search": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.olean", + "sha256": "61aca638560fc03fc81066bda85ae7ed4cd041d810cd6ccfc22126d34acddbd5" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.olean", + "sha256": "50bd8fa6211db0a214bd45a0f0e39b717459c16a30ecb25f9cb952d8375bccef" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.olean", + "sha256": "049f36bd49ee5222ca1f80966c97b13f53c4c7d9671d9cf496d582bf1c502671" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.olean", + "sha256": "d9541c657bbd8498736f341ac0e4389234e57be3d769b33a637f951da6e098f7" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.olean", + "sha256": "2da35cd1a1295137544c382e41dbe533cd98dc6fc18c92de7a0c8986518f48ac" + }, + "Lean.Meta.Tactic.Grind.Arith.Internalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.olean", + "sha256": "1f8dbae8cba46c6011d127e73c6d23e1594b3c13079a8167c9ff0b5d55ceaeb9" + }, + "Lean.Meta.Tactic.Grind.Arith.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Inv.olean", + "sha256": "0750fb3fce8b1e8ec98480b4b6ab8360e5f205371b1d575f53357702ae2bb702" + }, + "Lean.Meta.Tactic.Grind.Arith.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Main.olean", + "sha256": "8eb37977bf901bab0ad9873bfbde7c593fbaf6ff8d0c1c6de61597ec91de58c0" + }, + "Lean.Meta.Tactic.Grind.Arith.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Model.olean", + "sha256": "52f869b8a4523f3f8327495940a786c4670cf48b997d432c20640384e7301003" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset.olean", + "sha256": "bd8b615afcb4c53f5e711d9ab7f88881785088cd9b9f81c6b80b64432a916166" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.olean", + "sha256": "817db989d2e71b096c86076070f270ce02efefcf2c4b0cc8eb35a85ffe592097" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.olean", + "sha256": "3ffe0874b9209d41c8a12f845f4a23c37ed67985952ec8cf4fba6607b0d49bb2" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.olean", + "sha256": "13e17f706763e0e5001c386f41180d240fcc3cb3bb0e5b0704b1c6e89f8690dc" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.olean", + "sha256": "2af0eddf89eb682293b49189b0ecfdb86e7b2cb70ca6983d35edba6fc47b6825" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.olean", + "sha256": "cc0adfcd94231e97e1d8a5d9fd855b4ba06f77d4974d9f60bf8fcb1fad3429cb" + }, + "Lean.Meta.Tactic.Grind.Arith.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Types.olean", + "sha256": "6438183d9d97bcba306b3c98d0c4df35f16ae24156cbd92211a215ee8e0e9508" + }, + "Lean.Meta.Tactic.Grind.Arith.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Util.olean", + "sha256": "059afefed5207fd3bb58ff11aa196e5cb4fdd3d0c2f03f70ab3a302f3fb59612" + }, + "Lean.Meta.Tactic.Grind.Attr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Attr.olean", + "sha256": "e0809449692b76c1e0ae127a742c8c83858306fe2612eb59a238e5600e6437b0" + }, + "Lean.Meta.Tactic.Grind.Beta": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Beta.olean", + "sha256": "34027591ddea6317ba5bc6f29ec01c6a1cd2dc75c8b2af5b5d5e6fede7c2813f" + }, + "Lean.Meta.Tactic.Grind.Canon": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Canon.olean", + "sha256": "7e0dcfb39fd87bd7aa566da21f8cf3e0055adf5abdfab8c4dcd92ff022cffc99" + }, + "Lean.Meta.Tactic.Grind.Cases": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Cases.olean", + "sha256": "a79fdef9eaf0a5a89b2369d0374b43efa50ef7eb137bb143aea1b6968130fcd5" + }, + "Lean.Meta.Tactic.Grind.CasesMatch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/CasesMatch.olean", + "sha256": "cae5f088bd9191b15683eb230c385d3cf95b9cc36c5aa8fd237ef6abd6240e79" + }, + "Lean.Meta.Tactic.Grind.Combinators": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Combinators.olean", + "sha256": "573a8a2af44136b8fde8d93f561948f97b61ed2b0445b4af06a07e82901b004c" + }, + "Lean.Meta.Tactic.Grind.Core": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Core.olean", + "sha256": "603facdbeba83aeb053dc352948b86af9017b6a6e7b546a1a1516f03fea9c273" + }, + "Lean.Meta.Tactic.Grind.Ctor": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Ctor.olean", + "sha256": "2e49aeb70d54c80eecfae5c718a65d31917c4d875090b306049d463db43c230b" + }, + "Lean.Meta.Tactic.Grind.Diseq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Diseq.olean", + "sha256": "712b2965e98032727d42acecf75d2845c6d20828c9aa6f4cb7346b51100c6761" + }, + "Lean.Meta.Tactic.Grind.EMatch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatch.olean", + "sha256": "b3075bba2fa4af4839446ccc345b04063a1eeaf1f396aa027550e0d67eaf46d6" + }, + "Lean.Meta.Tactic.Grind.EMatchTheorem": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.olean", + "sha256": "7e393dd56ee80f27d92e457f4c2070d2fe2831142981438b7dff6b652ed6b12e" + }, + "Lean.Meta.Tactic.Grind.ENodeKey": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ENodeKey.olean", + "sha256": "ca0345179b9421b8efb30bed06820116843d9701e9c9f84e0824a0961b5251a5" + }, + "Lean.Meta.Tactic.Grind.EqResolution": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EqResolution.olean", + "sha256": "ed9d38ede8c44a14131ac484fcaac127fd889468856ea78f158cb8f7c7c5f9e1" + }, + "Lean.Meta.Tactic.Grind.Ext": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Ext.olean", + "sha256": "a7c1cee7f1e76d45b3787d0a7c2036967fffd7c6d780dad968bc5e08e0c674c7" + }, + "Lean.Meta.Tactic.Grind.ForallProp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ForallProp.olean", + "sha256": "923892a0ed79c2156b6df9cc23f561b77dc2c935ccb9b1d95122bab0e20fef97" + }, + "Lean.Meta.Tactic.Grind.Injection": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Injection.olean", + "sha256": "7c448e2fc0d16e61b6ad822651c7b35b8213dd18fbd4927017595d9fcd96af63" + }, + "Lean.Meta.Tactic.Grind.Internalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Internalize.olean", + "sha256": "7cd74b074c2e9deae6791b7045b6dec8f9056d41b96c9072020b051d67402323" + }, + "Lean.Meta.Tactic.Grind.Intro": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Intro.olean", + "sha256": "45d35493ac631af84097a78ea4b02bc5cc814c0ac8b598b36049279ac7ed87f3" + }, + "Lean.Meta.Tactic.Grind.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Inv.olean", + "sha256": "5111a484cd46c8d2263629540e4128cef9f30b74ccf62a6eded8ac56d8481fa3" + }, + "Lean.Meta.Tactic.Grind.MBTC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MBTC.olean", + "sha256": "596858a07ca041824937bfd08b38cdef09d32b08749962546f2b8abdb7e24192" + }, + "Lean.Meta.Tactic.Grind.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Main.olean", + "sha256": "e1e5ab7d0c967a50c2a38a5490a1a8c537e843da2c3f5a56e7cda971208bfd93" + }, + "Lean.Meta.Tactic.Grind.MarkNestedProofs": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MarkNestedProofs.olean", + "sha256": "3ab8dc54fab42c6683c63aae87ad0e606b3832d1f2391087ec7e698d5fa2fbcb" + }, + "Lean.Meta.Tactic.Grind.MatchCond": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchCond.olean", + "sha256": "ab35239747c6ca8c3833e709aaa2aa723d0525620ac2634241f72963ac9bed82" + }, + "Lean.Meta.Tactic.Grind.MatchDiscrOnly": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.olean", + "sha256": "0de0cdfbedfabfa048e98e885f3f1eea39e583aec8bcc2a50a5698f7a0df7884" + }, + "Lean.Meta.Tactic.Grind.PP": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/PP.olean", + "sha256": "23d560a5339928172099a9062d083f940a0a16e6c0b784dfe2a9f356e8682bb7" + }, + "Lean.Meta.Tactic.Grind.Parser": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Parser.olean", + "sha256": "052643551a1eb5fbfe4afdca2eb7ae6260628ef93f4813744cbda5a138eb751a" + }, + "Lean.Meta.Tactic.Grind.Proj": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Proj.olean", + "sha256": "1383ad6bc4a47cea522c9b9f542049aad4b818f4bf208ed98d1f56088d322a9a" + }, + "Lean.Meta.Tactic.Grind.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Proof.olean", + "sha256": "7e5f3d9016d71c938eb5bf7c6188d50dfe2b148189748b018e13d1d1f26758c0" + }, + "Lean.Meta.Tactic.Grind.Propagate": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Propagate.olean", + "sha256": "ba25b0259e25398cb28d7a6343b76a9ffae30a0e7759f2bbba03cf439d27ee49" + }, + "Lean.Meta.Tactic.Grind.PropagatorAttr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.olean", + "sha256": "c21c3865df64f8a2bdab20ab5a5658badebe0b370640e63e7ce8ae0620bc98b3" + }, + "Lean.Meta.Tactic.Grind.ProveEq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ProveEq.olean", + "sha256": "6fd15eeee6dce37a980a5036eb99716960dbbc6650d14b71cbd63a0f854578e7" + }, + "Lean.Meta.Tactic.Grind.RevertAll": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/RevertAll.olean", + "sha256": "63335a05f51b1b99b3bc891e774ed07ae7ccf470b36701c9a47472a2023b72dc" + }, + "Lean.Meta.Tactic.Grind.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Simp.olean", + "sha256": "eb9a419af181bdcc13018b73f8b5ef9b0cce6b3d8e69bb777a9464d54d7489d0" + }, + "Lean.Meta.Tactic.Grind.SimpUtil": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/SimpUtil.olean", + "sha256": "082ec13ed64da168e10a1d19d1f2080f417e069936488d9628652d2e83bf96ab" + }, + "Lean.Meta.Tactic.Grind.Solve": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Solve.olean", + "sha256": "838552f0e3f9901c03de3ee16533956fcc7677abcd393eaa85fc7e14c67c0c07" + }, + "Lean.Meta.Tactic.Grind.Split": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Split.olean", + "sha256": "9be21a776a8dbb641a0af947eebf4525341bfa829b3ae7e7ed5eb20855727d37" + }, + "Lean.Meta.Tactic.Grind.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Types.olean", + "sha256": "50bd2bb81627e5f915ee54c8730bb4d5403de12cca8a05a41f2f280b693772f9" + }, + "Lean.Meta.Tactic.Grind.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Util.olean", + "sha256": "02603b8094844f61ba32b6173beb06896e101dac5d581ca4ef9e82b17f4ba473" + }, + "Lean.Meta.Tactic.IndependentOf": { + "relative_path": "lib/lean/Lean/Meta/Tactic/IndependentOf.olean", + "sha256": "d6abc51e9488051912586a96926f55ddb9f0368c8891d5f89ff2d684122148fe" + }, + "Lean.Meta.Tactic.Induction": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Induction.olean", + "sha256": "a8fdc96571cc600fd47e2e68d84c51fe8afc537c08ab63d1e69ba5b4f518f4fa" + }, + "Lean.Meta.Tactic.Injection": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Injection.olean", + "sha256": "6d25fe6e9d8e4af470d9cd1074402577fd08575b0306faf9c78411c8a5e7578a" + }, + "Lean.Meta.Tactic.Intro": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Intro.olean", + "sha256": "a781ab0eafda9549477f2e90e0dc6ea708bbbda6d12f7390eaba879ecf6146a7" + }, + "Lean.Meta.Tactic.LibrarySearch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/LibrarySearch.olean", + "sha256": "c943f49809c5e0037e4239b05e441c2331cb48b24ca17f9146e5197458ed3ad6" + }, + "Lean.Meta.Tactic.NormCast": { + "relative_path": "lib/lean/Lean/Meta/Tactic/NormCast.olean", + "sha256": "8758122a8aa03b65194824837c9501ff7a57f6e56c3645ce16cd39935122465b" + }, + "Lean.Meta.Tactic.Refl": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Refl.olean", + "sha256": "39762b479efc2290610ab53ea0f9a7a67643f6684cb0fa5cdc1ff52cd5589d8a" + }, + "Lean.Meta.Tactic.Rename": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rename.olean", + "sha256": "633edd2088d9aab13bbb93c7da98451571c025dd4fa28c7adb7a1f14dede0a82" + }, + "Lean.Meta.Tactic.Repeat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Repeat.olean", + "sha256": "54854192d18a935b34a838ec68e7b5c86f7efc2831bbfe623057415260b84553" + }, + "Lean.Meta.Tactic.Replace": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Replace.olean", + "sha256": "a542783069ace49d9d9e92aa9f3cb725c98f94d5cdd4977a1154569dad20f1b5" + }, + "Lean.Meta.Tactic.Revert": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Revert.olean", + "sha256": "f6454fe8a940ada423be12c9a36033ecfbba13b71d0ed59fad2e9d522d46df10" + }, + "Lean.Meta.Tactic.Rewrite": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rewrite.olean", + "sha256": "3d61c66d1f775792f0c463b3ef6666a399fff92c2f7f1b29c605c99e02941897" + }, + "Lean.Meta.Tactic.Rewrites": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rewrites.olean", + "sha256": "5a2278edd2383bca036422ea43a484ccae7a0bb2bc7e7e15f0326a32e2330786" + }, + "Lean.Meta.Tactic.Rfl": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rfl.olean", + "sha256": "d2e5e722c4f2e3c9f291c02c05a671917d71aef645e34c0c01dbfd8a4ef23898" + }, + "Lean.Meta.Tactic.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp.olean", + "sha256": "a744b6973cd9b833699a6c19c0fa40e4dbfb6041fb08a6ca4de0823d3d56fae0" + }, + "Lean.Meta.Tactic.Simp.Arith": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith.olean", + "sha256": "b8b2030520be215f2121c9fab8608f7fd58ea80e48ffa5598fce3d1f948950c1" + }, + "Lean.Meta.Tactic.Simp.Arith.Int": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int.olean", + "sha256": "4f1c85c9e598fc31a7e1fc7e6f8d06d1c1eaa5146c624842e8ec87b58e5d9994" + }, + "Lean.Meta.Tactic.Simp.Arith.Int.Basic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.olean", + "sha256": "d03e49ecd4dfdec58f2ac9f261d983bea4023df4c78f7514bb7f6c40cdbb8bbf" + }, + "Lean.Meta.Tactic.Simp.Arith.Int.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.olean", + "sha256": "2766ba66e280f3beb4bae57de6de59a2f92647472cbe608bec350dbabdaaba11" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat.olean", + "sha256": "a035ca9e9317ad56e2e70046e0864586827218ad7e25cb7366fe532e010b1007" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat.Basic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.olean", + "sha256": "f80614c7ae4ff336b04162d11f2574e0848f38f72882fe919d759eaa09590f72" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.olean", + "sha256": "d77e898ebdaa21da0b6f6fa24eb4804a8b45ecf4ed7834aa26bfe8493b51148a" + }, + "Lean.Meta.Tactic.Simp.Arith.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Util.olean", + "sha256": "e43e2fa36cc77656ee34ca02b79897664215ce95e653cada87db0781111193ff" + }, + "Lean.Meta.Tactic.Simp.Attr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Attr.olean", + "sha256": "59dacc00728793da658e06c75bf20eb166ca57c100434714c7a7b7349149e99b" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.olean", + "sha256": "9e91488ad971f433fc8c18b870ddae5174f4fd8a80f9aee7e195223acf0813e7" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.olean", + "sha256": "aba24528cdf8549fefad4371d2ed8279dcc5bd4566d9ca59ccc721f760d51c56" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.olean", + "sha256": "18ba1c46202bae2dd5205e93db1df217fc9d213fbdc687452d9d76421437ef66" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.olean", + "sha256": "70bb04834a476008fe448165e8662a0437c82012e348ec19b6039773051fc91d" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.olean", + "sha256": "5b8217fa58f2deae0b8a99202da2367fedbf91cda77486d0ea9201b05a0720ae" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.olean", + "sha256": "fe618da592aafcfc1b597b118c88b962b603f55096926e7c77cd5f237a393c0e" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.olean", + "sha256": "9535c409ebeb0c3064e5b98fa9f953fbb93e15db3f2116dc46138ac0ff700c0a" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.List": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.olean", + "sha256": "93a9382bd2f855ac48c61e6886f02b85f81593552747a1dae72b3b10afc71a70" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.olean", + "sha256": "6b8d3d8807c31912616ae4818014da1e44cbfa398eeae525170b864185b3f324" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.olean", + "sha256": "a14d545e6a296624fbfc25dc02e8a49e0be6e3285f47960af9dbb766e872a024" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.String": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.olean", + "sha256": "bae98881832f2482d6e98c1b9eb11cc28e984ee2b7ac2d3e3d92ceade31bb7c6" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.olean", + "sha256": "9afaab454e44fd3c1a60907f38ee31b9057682bb6b66503e3136b23a0e51a0eb" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.olean", + "sha256": "97194969f1662051ced0134ccd1cbc4051c02ed0afd46ecff6daafb413645652" + }, + "Lean.Meta.Tactic.Simp.Diagnostics": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Diagnostics.olean", + "sha256": "8fb74efbbe0d898b4bee2b53a996bb925cd3dfdd4bf3098086d07fdad9c093f6" + }, + "Lean.Meta.Tactic.Simp.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Main.olean", + "sha256": "90f3c5c41d8d10a7b82110a9d188db8661f730c8430102696a6050a9e819944d" + }, + "Lean.Meta.Tactic.Simp.RegisterCommand": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/RegisterCommand.olean", + "sha256": "5e296fcd42394e5fa5a137358753eb347872076a0e8dc3ef5e31b483ac58af39" + }, + "Lean.Meta.Tactic.Simp.Rewrite": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Rewrite.olean", + "sha256": "e6377cde2f937751efc04e43b032505bfed7ec5c1f13678c3cb456268e90d2c2" + }, + "Lean.Meta.Tactic.Simp.SimpAll": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpAll.olean", + "sha256": "f2aedf17c8196a3fcc3ba0a79d2dee82b6599e2623e0e5336940943fe294316d" + }, + "Lean.Meta.Tactic.Simp.SimpCongrTheorems": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.olean", + "sha256": "2a29138060df8d5e09ad070b170d167fc490713073b36b38371e676c83578119" + }, + "Lean.Meta.Tactic.Simp.SimpTheorems": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpTheorems.olean", + "sha256": "b6f48b1bf34a7832d9a809b108a3aa8606c13afd2376b6c2c79f7045425e0e7d" + }, + "Lean.Meta.Tactic.Simp.Simproc": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Simproc.olean", + "sha256": "913ac372ccd4b4445b346d16d2ba702bf74d8ea65e62401b7b502b016bc82750" + }, + "Lean.Meta.Tactic.Simp.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Types.olean", + "sha256": "382bf34c3320d34ce0ba097804f91ee702480fb358709d1a376399ab20ae2767" + }, + "Lean.Meta.Tactic.SolveByElim": { + "relative_path": "lib/lean/Lean/Meta/Tactic/SolveByElim.olean", + "sha256": "65859e5f73882352b2e665afdd9ae7f9dbd122ef99cdaa6422fc4e37c030d459" + }, + "Lean.Meta.Tactic.Split": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Split.olean", + "sha256": "0e8d4c9c735a78acc8977e81bc84bd39d2390093d889445f006ba6d5f6ad5b3d" + }, + "Lean.Meta.Tactic.SplitIf": { + "relative_path": "lib/lean/Lean/Meta/Tactic/SplitIf.olean", + "sha256": "a39ffae4f96a41e30a2c3a88468103c3c716942214fc8805357490e903b2ef67" + }, + "Lean.Meta.Tactic.Subst": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Subst.olean", + "sha256": "44938a993d4998ad3140ba161843cf52fc0f01d8eb04dc105433e74f57e13dba" + }, + "Lean.Meta.Tactic.Symm": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Symm.olean", + "sha256": "9e576fa9ccc14f72a6d4b75f9ccb133f5463c531031fc0abcd81f9ce1e002b6b" + }, + "Lean.Meta.Tactic.Try": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Try.olean", + "sha256": "e2c566144935639f447b2493030d97204d22cfb866bd8c767ec0fba491cb56c2" + }, + "Lean.Meta.Tactic.Try.Collect": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Try/Collect.olean", + "sha256": "eb58abadce47d13437cc648de8c9c4d34965bde2b5b8c0fb5be46aa7c2f709bb" + }, + "Lean.Meta.Tactic.TryThis": { + "relative_path": "lib/lean/Lean/Meta/Tactic/TryThis.olean", + "sha256": "b0a43bfa4c21d9d9c9181de4783e7f7637862e6799dc17a94ffd41b6b8320535" + }, + "Lean.Meta.Tactic.Unfold": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Unfold.olean", + "sha256": "c512bf7a8ddc53bc480ed017efccdce73fa6a65ff3bc8026fcdb45108910a8f1" + }, + "Lean.Meta.Tactic.UnifyEq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/UnifyEq.olean", + "sha256": "17895f0232b1c9b37739a6678bc125d5481c4711fd70dcc2e0d7533d2ae7d88a" + }, + "Lean.Meta.Tactic.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Util.olean", + "sha256": "26f024806a3c5a844167cad452c161e17dd535f37c2f70f76fa8d0e98ac7d898" + }, + "Lean.Meta.Transform": { + "relative_path": "lib/lean/Lean/Meta/Transform.olean", + "sha256": "0fad85dd417e805f932c54eada13d21053a7457b9154026cf16b38e3458fc759" + }, + "Lean.Meta.TransparencyMode": { + "relative_path": "lib/lean/Lean/Meta/TransparencyMode.olean", + "sha256": "8f195daac0641aeeb14c47bb8989f99929ddb79329d5b64dd4349bc21ad52fdc" + }, + "Lean.Meta.UnificationHint": { + "relative_path": "lib/lean/Lean/Meta/UnificationHint.olean", + "sha256": "f6400a3713e4a9a72e4f2ef064ebe692706c0f21f186dce75250fe6eb4138a85" + }, + "Lean.Meta.WHNF": { + "relative_path": "lib/lean/Lean/Meta/WHNF.olean", + "sha256": "13939b1cdb2a81230a5445e9836dadeead92b5810b293c5da265451f02dd516f" + }, + "Lean.MetavarContext": { + "relative_path": "lib/lean/Lean/MetavarContext.olean", + "sha256": "616fb991aae42c8780c3566eadfe5e7cbabbf4779da1cf138014130772a668e1" + }, + "Lean.Modifiers": { + "relative_path": "lib/lean/Lean/Modifiers.olean", + "sha256": "34a8b59c7358c3a176430743f45ff649c47511e16e8b38bc763e3d63d82d11ae" + }, + "Lean.MonadEnv": { + "relative_path": "lib/lean/Lean/MonadEnv.olean", + "sha256": "086512b6ccf3afb524b665d93bfa512c8d2f699dd55ee4d59acab9376c379659" + }, + "Lean.Namespace": { + "relative_path": "lib/lean/Lean/Namespace.olean", + "sha256": "a4eb3519381836c10a0afd99e58a248135c277cd2a9489cc77636877914df692" + }, + "Lean.Parser": { + "relative_path": "lib/lean/Lean/Parser.olean", + "sha256": "28d395e6f52a72577be7747cfd60a84d5fef0edbff614963675e7103f43ce066" + }, + "Lean.Parser.Attr": { + "relative_path": "lib/lean/Lean/Parser/Attr.olean", + "sha256": "d37af508df519b54e878fdf29c6ff2006c4ab3d66c189302f2e28d50fb53d01e" + }, + "Lean.Parser.Basic": { + "relative_path": "lib/lean/Lean/Parser/Basic.olean", + "sha256": "948a51872ed931dcd069d6717532f02760ec64f1acfd6862fc5d222cc6aedeb0" + }, + "Lean.Parser.Command": { + "relative_path": "lib/lean/Lean/Parser/Command.olean", + "sha256": "a095b104d809b21d76722139623c677f932cbe8f33f79077c0f7469facaa4d21" + }, + "Lean.Parser.Do": { + "relative_path": "lib/lean/Lean/Parser/Do.olean", + "sha256": "0d97f39e5ec556f827c8399724fc2c7ad26b9b7a3aa8583158c1b335d2962edc" + }, + "Lean.Parser.Extension": { + "relative_path": "lib/lean/Lean/Parser/Extension.olean", + "sha256": "3d5387205b22b17b0449553339d1449481eb01d1f90424c1920521dfbbd6a51d" + }, + "Lean.Parser.Extra": { + "relative_path": "lib/lean/Lean/Parser/Extra.olean", + "sha256": "26993ef7f1b0dc107e5a54f5346becb1ed7df9e287a9716ba9a90dc25cb5597a" + }, + "Lean.Parser.Level": { + "relative_path": "lib/lean/Lean/Parser/Level.olean", + "sha256": "028076fe879c3d1f470248400637a3b2a404bd2807c6b1c42bd9f19b37a87385" + }, + "Lean.Parser.Module": { + "relative_path": "lib/lean/Lean/Parser/Module.olean", + "sha256": "1cd96b90357d48c1313be94c170a60e06deab7c2230a7684a5d3ad39a41a1453" + }, + "Lean.Parser.StrInterpolation": { + "relative_path": "lib/lean/Lean/Parser/StrInterpolation.olean", + "sha256": "1f275289f803e6362acbbdbb64dcbd1f4b63a25d01b96104d8bad7419712270a" + }, + "Lean.Parser.Syntax": { + "relative_path": "lib/lean/Lean/Parser/Syntax.olean", + "sha256": "b7d13deae25970c03965ab71ee15b6079948b4031f5c7877b19253d75b32a9a8" + }, + "Lean.Parser.Tactic": { + "relative_path": "lib/lean/Lean/Parser/Tactic.olean", + "sha256": "1d5f60bbb0520f7381c7942188f25406b178ed74e64c6995b8136e9d410617c9" + }, + "Lean.Parser.Tactic.Doc": { + "relative_path": "lib/lean/Lean/Parser/Tactic/Doc.olean", + "sha256": "de5fa176afd2efb06130e19b1fad85a782e8f6c70abd81e07410c06bdaaf435c" + }, + "Lean.Parser.Term": { + "relative_path": "lib/lean/Lean/Parser/Term.olean", + "sha256": "c27cd04030908ee1296d32a8230508cf878e37d3d9b55dc54a33dfd8f7bbcbaf" + }, + "Lean.Parser.Term.Doc": { + "relative_path": "lib/lean/Lean/Parser/Term/Doc.olean", + "sha256": "48344268b22b852d1c35ae1a717dcd804b7e02cb6619538b521a0f9f7c5b75ec" + }, + "Lean.Parser.Types": { + "relative_path": "lib/lean/Lean/Parser/Types.olean", + "sha256": "ebb9269d0c74ef1b84ed10af9a0fcfebd8c5f06af78ea8b7de52fab501ec3801" + }, + "Lean.ParserCompiler": { + "relative_path": "lib/lean/Lean/ParserCompiler.olean", + "sha256": "dfcf227a5095244c4f18259255e84b7d7486916a13d15cc7d494bf8327e7ea01" + }, + "Lean.ParserCompiler.Attribute": { + "relative_path": "lib/lean/Lean/ParserCompiler/Attribute.olean", + "sha256": "0635f545bec6dc4635f71024582d1e77d8ea6ace85b71d596c241b8c5cbb7ae0" + }, + "Lean.PremiseSelection": { + "relative_path": "lib/lean/Lean/PremiseSelection.olean", + "sha256": "84ad62edb54be2f55ea548421e59915503f678f5a689528429cbd6b3a47f52c3" + }, + "Lean.PrettyPrinter": { + "relative_path": "lib/lean/Lean/PrettyPrinter.olean", + "sha256": "f3c54ec68adb7b306e7de49fe6e1cc53c591053f6d772c125120e35cc0e42762" + }, + "Lean.PrettyPrinter.Basic": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Basic.olean", + "sha256": "5c155123ea1a5935403072f161006d3609e769fa5971cc83b99217c93d269a70" + }, + "Lean.PrettyPrinter.Delaborator": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator.olean", + "sha256": "2832e05f38fb87dd795cde9f6529793009807c6599a36ca0655f04eceb2c216c" + }, + "Lean.PrettyPrinter.Delaborator.Attributes": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Attributes.olean", + "sha256": "f98afcbf332723561b6d466a6c129844cdaff8b8f55e79f43a0040d1a0eb6a5c" + }, + "Lean.PrettyPrinter.Delaborator.Basic": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Basic.olean", + "sha256": "e402ce6c7c87da5752f1ec58b3032275db4ee722342a55bc118ac16ccb31b129" + }, + "Lean.PrettyPrinter.Delaborator.Builtins": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Builtins.olean", + "sha256": "02e8e2ec8a01f0eeba7212f5f3731bad7811680c44c03045391acd6222e8246a" + }, + "Lean.PrettyPrinter.Delaborator.FieldNotation": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.olean", + "sha256": "0fd7dac9c26de870462ff5c02bfa167ddba6d4b6f5616e9cd0849bf410997dc1" + }, + "Lean.PrettyPrinter.Delaborator.Options": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Options.olean", + "sha256": "83038fe17fe8486d5c2d49c942c60f40a56a857ea203991d52b0877f4c96ebdd" + }, + "Lean.PrettyPrinter.Delaborator.SubExpr": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/SubExpr.olean", + "sha256": "0d284ad4e40cc16bff17d232de10dee13bfa15b68eeda439218984488a864cef" + }, + "Lean.PrettyPrinter.Delaborator.TopDownAnalyze": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.olean", + "sha256": "ae6466c25b02f08e0b5fdfa1d2905b521de447c99ed580026aeaf3fcbac14d54" + }, + "Lean.PrettyPrinter.Formatter": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Formatter.olean", + "sha256": "348c5cf96f47b9c3b5d672b87913ac267d4c9f6ab5cc6e1e46757b9a4898470f" + }, + "Lean.PrettyPrinter.Parenthesizer": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Parenthesizer.olean", + "sha256": "d11ccf31a884b96dd8e7ce4a3d0be88ee37572282cc77235996eb06283ff9e1e" + }, + "Lean.PrivateName": { + "relative_path": "lib/lean/Lean/PrivateName.olean", + "sha256": "01331d62033f1a153ccfce0e26b19eec216989653b9170e09690f3f30017cd9e" + }, + "Lean.ProjFns": { + "relative_path": "lib/lean/Lean/ProjFns.olean", + "sha256": "b4e573e1214a33dfb17c70b252e55c42d56cbaa3ee3a02b620fc3cb238587772" + }, + "Lean.ReducibilityAttrs": { + "relative_path": "lib/lean/Lean/ReducibilityAttrs.olean", + "sha256": "4474586ad1da6481575424de924659c612a3e8c6b715ddf34fc26039d2e51e29" + }, + "Lean.Replay": { + "relative_path": "lib/lean/Lean/Replay.olean", + "sha256": "b99332f1e48cab089d45ecc5b6fadb71f95adb915b95ac7d5f513b8866b65d4e" + }, + "Lean.ReservedNameAction": { + "relative_path": "lib/lean/Lean/ReservedNameAction.olean", + "sha256": "c4c0b3460d35f4083a2459f232a0ff881e69092173963b6a671550a8640b3b41" + }, + "Lean.ResolveName": { + "relative_path": "lib/lean/Lean/ResolveName.olean", + "sha256": "1c5302ed5d1925a703364dbb22a84eb835a738d1073a1f576eafb4551b2f6863" + }, + "Lean.Runtime": { + "relative_path": "lib/lean/Lean/Runtime.olean", + "sha256": "f2c44c67f19cf22efd8c35ebb08d645de14a15341ce43055392e503f90c96ebf" + }, + "Lean.ScopedEnvExtension": { + "relative_path": "lib/lean/Lean/ScopedEnvExtension.olean", + "sha256": "a81bf05e51a27486ca11bb4b7f627a71278be383d69c04380886f8be0d7fd0fe" + }, + "Lean.Server": { + "relative_path": "lib/lean/Lean/Server.olean", + "sha256": "bbd9570762b5728fbeba1cd4fb6e1e63d0dc1e2f2b117cafd9e7fcae9bad7637" + }, + "Lean.Server.AsyncList": { + "relative_path": "lib/lean/Lean/Server/AsyncList.olean", + "sha256": "d9ecedd556a8565e22c4c4ef375e498bcf46cff541631685e3c6bb59da13ec06" + }, + "Lean.Server.CodeActions": { + "relative_path": "lib/lean/Lean/Server/CodeActions.olean", + "sha256": "1ffd438b12bf14992169052902dc91ff981fbffbd5b9d9dc3cd351afadf2d924" + }, + "Lean.Server.CodeActions.Attr": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Attr.olean", + "sha256": "21177a969ea2086c19c19a7d71a2d66acd666bfbd49c77dff89a2193ab911100" + }, + "Lean.Server.CodeActions.Basic": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Basic.olean", + "sha256": "3092af6beab4d2ccbcdc4d3c493887fbc61d2fd8c6507359d8dc81515af83350" + }, + "Lean.Server.CodeActions.Provider": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Provider.olean", + "sha256": "aca19e7414b6c15aa725debc884e06aa48515bc10f78bdac847e92a0d3355945" + }, + "Lean.Server.Completion": { + "relative_path": "lib/lean/Lean/Server/Completion.olean", + "sha256": "2d2b0e130132eee10776deb68540afbf5c588598b4f858be9850099e64e8039e" + }, + "Lean.Server.Completion.CompletionCollectors": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionCollectors.olean", + "sha256": "ca660a9b742f1e2f6adf50cc33847122c9bc017880a643d63a56053091cb9f8d" + }, + "Lean.Server.Completion.CompletionInfoSelection": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionInfoSelection.olean", + "sha256": "229a4e0e5238f4af4a9165f077e381a739b385a957ec1fe5590d0329711a221d" + }, + "Lean.Server.Completion.CompletionItemData": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionItemData.olean", + "sha256": "aa592a1060191b06553a282b4e2c23583260bbd32f193fdd82a2a0e3881b2ea5" + }, + "Lean.Server.Completion.CompletionResolution": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionResolution.olean", + "sha256": "1f1e99acc389c5ef5818bcc8c7c5e2a2ed0058e0be93661a2b2aaf6c4ccf3220" + }, + "Lean.Server.Completion.CompletionUtils": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionUtils.olean", + "sha256": "1b68673e815b0792013d12790d4bcf8768326df0b7ff0244cf27d3b1fb4603d7" + }, + "Lean.Server.Completion.EligibleHeaderDecls": { + "relative_path": "lib/lean/Lean/Server/Completion/EligibleHeaderDecls.olean", + "sha256": "f71255170c2f18efa266279cda6ec56942e0975689ccd22ec7eaaff127d8433b" + }, + "Lean.Server.Completion.ImportCompletion": { + "relative_path": "lib/lean/Lean/Server/Completion/ImportCompletion.olean", + "sha256": "aed78476c5e3c1d841563b30a1076e4d8392383fc0ba65273f50f96057bb3a5e" + }, + "Lean.Server.Completion.SyntheticCompletion": { + "relative_path": "lib/lean/Lean/Server/Completion/SyntheticCompletion.olean", + "sha256": "6d1733deb5c375a5d09f69a8719d6f0cd91659aac517071e22d50d8c1072d2ca" + }, + "Lean.Server.FileSource": { + "relative_path": "lib/lean/Lean/Server/FileSource.olean", + "sha256": "e28757c52a99267f3c788a9e83b0d30a1461d4113065f45444269fdf7b18f9ae" + }, + "Lean.Server.FileWorker": { + "relative_path": "lib/lean/Lean/Server/FileWorker.olean", + "sha256": "f6529233eb4cc58fd4ce7426ece4285e7b294fcd924f80e60759a609ce75ab4c" + }, + "Lean.Server.FileWorker.ExampleHover": { + "relative_path": "lib/lean/Lean/Server/FileWorker/ExampleHover.olean", + "sha256": "159199fc8757162b59d3e4882a5adde20b9d30f1e1c2e9d73f2d431d8225f8b2" + }, + "Lean.Server.FileWorker.InlayHints": { + "relative_path": "lib/lean/Lean/Server/FileWorker/InlayHints.olean", + "sha256": "a6a0a9f601e15e5f0a4f1a4c58cccfa47a090ddcea06b087cf4d35f83bc8acb8" + }, + "Lean.Server.FileWorker.RequestHandling": { + "relative_path": "lib/lean/Lean/Server/FileWorker/RequestHandling.olean", + "sha256": "bb4929eaa8e2895d7dede2dfcee916694296993384310e57cb44c2f207c769cb" + }, + "Lean.Server.FileWorker.SemanticHighlighting": { + "relative_path": "lib/lean/Lean/Server/FileWorker/SemanticHighlighting.olean", + "sha256": "18293c05d11ec7a4479e7139013a5da2244e92d2a15f6fe0683f5aa25910839c" + }, + "Lean.Server.FileWorker.SetupFile": { + "relative_path": "lib/lean/Lean/Server/FileWorker/SetupFile.olean", + "sha256": "6aadbc90fb133de6196241264b5e9199eb20873ac28c97fd525020b9d1ff8117" + }, + "Lean.Server.FileWorker.Utils": { + "relative_path": "lib/lean/Lean/Server/FileWorker/Utils.olean", + "sha256": "fb1141d854ddd8285b816247a29f6c73f55bdbb57598d5b23b5689b2dd5bc6b4" + }, + "Lean.Server.FileWorker.WidgetRequests": { + "relative_path": "lib/lean/Lean/Server/FileWorker/WidgetRequests.olean", + "sha256": "b6a3538e82fcf0053a603dd6b89dae5ac056f25833d5af7671d9f5730eccc0be" + }, + "Lean.Server.GoTo": { + "relative_path": "lib/lean/Lean/Server/GoTo.olean", + "sha256": "18aa8fbcc0ca8c945db6e6aa3eed8ed4ca27a7c9e08ba86af3f8be0828608cf4" + }, + "Lean.Server.InfoUtils": { + "relative_path": "lib/lean/Lean/Server/InfoUtils.olean", + "sha256": "77b7e95c6f553154b841639d2aa3bb24346e89434327ddcb557b5982e4de69de" + }, + "Lean.Server.References": { + "relative_path": "lib/lean/Lean/Server/References.olean", + "sha256": "de438915fcb962e19d09bfd1905df6632459853730bf416cbe9c1bcae4fe515f" + }, + "Lean.Server.RequestCancellation": { + "relative_path": "lib/lean/Lean/Server/RequestCancellation.olean", + "sha256": "cd8942ec9337da649a58c9f8ea7f01ecce2383c59e080f22116f48f386be3ee0" + }, + "Lean.Server.Requests": { + "relative_path": "lib/lean/Lean/Server/Requests.olean", + "sha256": "0ae37f883b90fbbbb165411871f2f1bf1cc6f166efca062dd8869f14c845c828" + }, + "Lean.Server.Rpc": { + "relative_path": "lib/lean/Lean/Server/Rpc.olean", + "sha256": "640216f0a569300668056ade5912685e2a0543328feba76d00a752859c3b692d" + }, + "Lean.Server.Rpc.Basic": { + "relative_path": "lib/lean/Lean/Server/Rpc/Basic.olean", + "sha256": "09a13a5b0eb1c751cf1689334e7d858d4db582a65bd458efd638a20153839f73" + }, + "Lean.Server.Rpc.Deriving": { + "relative_path": "lib/lean/Lean/Server/Rpc/Deriving.olean", + "sha256": "398279634e15fa8d0aa9394bc63d5ec59a867598db64d76e4772549ba8d29aec" + }, + "Lean.Server.Rpc.RequestHandling": { + "relative_path": "lib/lean/Lean/Server/Rpc/RequestHandling.olean", + "sha256": "0af5a93b3960757ec7bc913b866e9c8bb12a0d3d966d5701f526174d53342c8e" + }, + "Lean.Server.ServerTask": { + "relative_path": "lib/lean/Lean/Server/ServerTask.olean", + "sha256": "5b6e96d39b1fb04527dfe5efb97b1118c1947d723f31cac6c97f8815ad8624a5" + }, + "Lean.Server.Snapshots": { + "relative_path": "lib/lean/Lean/Server/Snapshots.olean", + "sha256": "0fc97604d59c24d8ee81fd5a63dc5ae1abbdc7f9d88e4cdb15eaaee0d0da0991" + }, + "Lean.Server.Test": { + "relative_path": "lib/lean/Lean/Server/Test.olean", + "sha256": "2afbefa351dbf1bcf23b5bfaad40f909905680ad39e528f867b4c463d3db58b1" + }, + "Lean.Server.Test.Cancel": { + "relative_path": "lib/lean/Lean/Server/Test/Cancel.olean", + "sha256": "f33dbeb8bdf19c481feee5ee16bae1d773e043a294995bd4a11f94f604b8771b" + }, + "Lean.Server.Test.Runner": { + "relative_path": "lib/lean/Lean/Server/Test/Runner.olean", + "sha256": "1c8d1946a902c7331616a9a9f7be3d8db6dd5bbe233698c23150fa37043b147d" + }, + "Lean.Server.Utils": { + "relative_path": "lib/lean/Lean/Server/Utils.olean", + "sha256": "c2a03554a131bed630c8b57d965b78c635062a6ac5d29086d801b76e9c3c1e5e" + }, + "Lean.Server.Watchdog": { + "relative_path": "lib/lean/Lean/Server/Watchdog.olean", + "sha256": "25bdfc1d26766745f8123b35795cf75cc03b3d067d7fa917d746a89972fa1081" + }, + "Lean.Structure": { + "relative_path": "lib/lean/Lean/Structure.olean", + "sha256": "1cce03c390b480c9ccfdc752f482f5772f9e8191a89ac2f92dbb371293edce08" + }, + "Lean.SubExpr": { + "relative_path": "lib/lean/Lean/SubExpr.olean", + "sha256": "56463ec2e047a75bc9582f7cba3698476c0595b80ad936524481c97edc7c57bb" + }, + "Lean.Syntax": { + "relative_path": "lib/lean/Lean/Syntax.olean", + "sha256": "1257d7730ef2a59134c6d3a66b812bd28464a93e906d80aa684118a2a2f7e41c" + }, + "Lean.ToExpr": { + "relative_path": "lib/lean/Lean/ToExpr.olean", + "sha256": "681106024aa58dff7c5dbea53ef9b5e01c166267413e6603fb59f7e6ba4705e4" + }, + "Lean.ToLevel": { + "relative_path": "lib/lean/Lean/ToLevel.olean", + "sha256": "0f1039c2e1e3a4e024294fe8827de0b83809ef22d6f95141a20f17bfd57010ed" + }, + "Lean.Util": { + "relative_path": "lib/lean/Lean/Util.olean", + "sha256": "b3804c0b6fd4187caaa395cdbf07b210634c36b5862e5b01e99a334894041ac5" + }, + "Lean.Util.CollectAxioms": { + "relative_path": "lib/lean/Lean/Util/CollectAxioms.olean", + "sha256": "9dd674224d00ea6e9044e05e9022d0997ed842b0eceee5157da199ea523614d3" + }, + "Lean.Util.CollectFVars": { + "relative_path": "lib/lean/Lean/Util/CollectFVars.olean", + "sha256": "03e91ed3ea63c86fa4a74f01eb026cba7a3c7a9a66e911f3420388bf0a24b06a" + }, + "Lean.Util.CollectLevelMVars": { + "relative_path": "lib/lean/Lean/Util/CollectLevelMVars.olean", + "sha256": "ee4f7731ff6e32e49c472ecc660fe70b7e8e28a9fe3e787d95968fc334cdafb9" + }, + "Lean.Util.CollectLevelParams": { + "relative_path": "lib/lean/Lean/Util/CollectLevelParams.olean", + "sha256": "f57df1551f35babfbd25cd4d786d36ca1c1e668a7dc733f1e86a7768a898c70e" + }, + "Lean.Util.CollectMVars": { + "relative_path": "lib/lean/Lean/Util/CollectMVars.olean", + "sha256": "1c5fc9f6e4a37382985419959a6a9e223763b770d78238e26e3b2029565d201e" + }, + "Lean.Util.Diff": { + "relative_path": "lib/lean/Lean/Util/Diff.olean", + "sha256": "348b407f6ab6b4cea1c17189e88ad4449669db50724e85bf333a7cd6eef01f8f" + }, + "Lean.Util.FVarSubset": { + "relative_path": "lib/lean/Lean/Util/FVarSubset.olean", + "sha256": "931302f6ee0fa3706536bf4c786d63c55903ee608fcfee3a7e62a884230b4689" + }, + "Lean.Util.FileSetupInfo": { + "relative_path": "lib/lean/Lean/Util/FileSetupInfo.olean", + "sha256": "fedeae0565096639cc7344c39c75dcd51760d451cf9e3bae3f67403fa3301420" + }, + "Lean.Util.FindExpr": { + "relative_path": "lib/lean/Lean/Util/FindExpr.olean", + "sha256": "fc9f82a261866735ac5f16c64903d5cd7ce354a5d559359f69e14c066299b82a" + }, + "Lean.Util.FindLevelMVar": { + "relative_path": "lib/lean/Lean/Util/FindLevelMVar.olean", + "sha256": "efa86d730a224bac9f9559414945fb8e4480adf9bd5c6f614bc386ccef4b79a8" + }, + "Lean.Util.FindMVar": { + "relative_path": "lib/lean/Lean/Util/FindMVar.olean", + "sha256": "f7c599d6b22db24fed3d4572b254ef1f625abbf242dc21a376a123913fbeaadd" + }, + "Lean.Util.FoldConsts": { + "relative_path": "lib/lean/Lean/Util/FoldConsts.olean", + "sha256": "30a5b555e3da24c6138cda39b0ce2fdd2898549424f3f48a5f0ad5a84a6ad024" + }, + "Lean.Util.ForEachExpr": { + "relative_path": "lib/lean/Lean/Util/ForEachExpr.olean", + "sha256": "f9b3a9c2bd938afe1ed5bfe2cdaac38da291c1f9cbc3ef00c6d70fe18c48b38c" + }, + "Lean.Util.ForEachExprWhere": { + "relative_path": "lib/lean/Lean/Util/ForEachExprWhere.olean", + "sha256": "0f66cc8ae514f42e32e37450023f5325c013a5f3b31cc00643b305ec2050a813" + }, + "Lean.Util.HasConstCache": { + "relative_path": "lib/lean/Lean/Util/HasConstCache.olean", + "sha256": "997838afe6cdc2068b866980bbc2d9571e08821ec262b3f96b5d182bda4d1e41" + }, + "Lean.Util.Heartbeats": { + "relative_path": "lib/lean/Lean/Util/Heartbeats.olean", + "sha256": "ef98dc435a31b539200931e89b2d3f08bd6e7f689e00ec3522ab1210b86e672d" + }, + "Lean.Util.InstantiateLevelParams": { + "relative_path": "lib/lean/Lean/Util/InstantiateLevelParams.olean", + "sha256": "f05e8a234de5794988814cab37b89a021d6e869311cd4fa372ab4f9ee2124424" + }, + "Lean.Util.LakePath": { + "relative_path": "lib/lean/Lean/Util/LakePath.olean", + "sha256": "dd00ea5edef5aeaf9d68948e3616d4de5052a4ac3e2acb67126898567f3fdb1b" + }, + "Lean.Util.LeanOptions": { + "relative_path": "lib/lean/Lean/Util/LeanOptions.olean", + "sha256": "036d4d32660acc69d0fc60938f15ea9ffa1edc7440340197d5d09dfbf7482e02" + }, + "Lean.Util.MonadBacktrack": { + "relative_path": "lib/lean/Lean/Util/MonadBacktrack.olean", + "sha256": "3a721336f768b1bd3d838101868b17bdcddb936acbe232601080cb47dae6bdef" + }, + "Lean.Util.MonadCache": { + "relative_path": "lib/lean/Lean/Util/MonadCache.olean", + "sha256": "a49bf6318c1fa4b7642ee350d0a0adfd5c9c30edfdbf5375bb08c27e89b9d09e" + }, + "Lean.Util.NumApps": { + "relative_path": "lib/lean/Lean/Util/NumApps.olean", + "sha256": "5e9a3b8f61219d6eb81d5e68ebf9783b3e653e6d2cad90d35d7fa1edaf48498d" + }, + "Lean.Util.NumObjs": { + "relative_path": "lib/lean/Lean/Util/NumObjs.olean", + "sha256": "1b6dcd0400b21b6478e0690faf12be333ac561dee8edf34fa9d940e0536d9c8d" + }, + "Lean.Util.OccursCheck": { + "relative_path": "lib/lean/Lean/Util/OccursCheck.olean", + "sha256": "2105d2cafdc97780ed80d0c21d96e3a96eb8c5b27c6f478ad8f511ff1d307a39" + }, + "Lean.Util.PPExt": { + "relative_path": "lib/lean/Lean/Util/PPExt.olean", + "sha256": "a5c502d22177658a419a532038b821f28cef4fa7a32e3c2544726ddd0b019c5e" + }, + "Lean.Util.Path": { + "relative_path": "lib/lean/Lean/Util/Path.olean", + "sha256": "75e708dc5859e0639e7eceae77d508a187db39ccb6cab080143e8dd26d4a0304" + }, + "Lean.Util.Paths": { + "relative_path": "lib/lean/Lean/Util/Paths.olean", + "sha256": "74142ed1f2181bb4102c8a0f6e41d41a4c658232937fc597f4e4b1c2a183b1bc" + }, + "Lean.Util.Profile": { + "relative_path": "lib/lean/Lean/Util/Profile.olean", + "sha256": "f23c4842d954d119e83de4dde14edb34981d6994cbeea4de9c2ae381f17bf831" + }, + "Lean.Util.Profiler": { + "relative_path": "lib/lean/Lean/Util/Profiler.olean", + "sha256": "1e9a3eec7c150b0e9ca1c785861eabb3f9a9c35a00d105c513439ec840a7ccbc" + }, + "Lean.Util.PtrSet": { + "relative_path": "lib/lean/Lean/Util/PtrSet.olean", + "sha256": "231e789db2045483e7600fec9903afba50dbba3e95c8c925982e2c1ea71b8a17" + }, + "Lean.Util.RecDepth": { + "relative_path": "lib/lean/Lean/Util/RecDepth.olean", + "sha256": "ea7a31d5424201f52482f7a9bf6de3ed5e0f8e741c131b78551fc6ac47b6b357" + }, + "Lean.Util.Recognizers": { + "relative_path": "lib/lean/Lean/Util/Recognizers.olean", + "sha256": "6ce3043ebd4aeb4bf7e43914580fc3fc414635d908d152ac393c283e07d0c2ce" + }, + "Lean.Util.ReplaceExpr": { + "relative_path": "lib/lean/Lean/Util/ReplaceExpr.olean", + "sha256": "aee2465ad5bf2bba0f52b8a4ea4b444990bcf68e15c7e32c387f31fb5a4606ec" + }, + "Lean.Util.ReplaceLevel": { + "relative_path": "lib/lean/Lean/Util/ReplaceLevel.olean", + "sha256": "bbdf8e6a5aa715de21a3edea51c9e0798e40fdffbd4896d15a3202d19e21bc21" + }, + "Lean.Util.SCC": { + "relative_path": "lib/lean/Lean/Util/SCC.olean", + "sha256": "f4ecd7303b846253b6aa74f4910f1c97089995e20ea654d78572898ea5ab764a" + }, + "Lean.Util.SafeExponentiation": { + "relative_path": "lib/lean/Lean/Util/SafeExponentiation.olean", + "sha256": "6ac2c719d74ffd8ec932fed7ea38541bb0bd64b1db68c15e143f1b31b7905a03" + }, + "Lean.Util.SearchPath": { + "relative_path": "lib/lean/Lean/Util/SearchPath.olean", + "sha256": "5c541f16a00ce65845346ff39f3e52602ba24873f9143b696ad31a35d0d0b174" + }, + "Lean.Util.ShareCommon": { + "relative_path": "lib/lean/Lean/Util/ShareCommon.olean", + "sha256": "041136336e252a66b1e09dbb0509423603f964469b9f41f34bb45cb47319683a" + }, + "Lean.Util.Sorry": { + "relative_path": "lib/lean/Lean/Util/Sorry.olean", + "sha256": "dc16c4717cb1b982328f48069d111d46ec937d63bf7648c94811c2ac7f8978a5" + }, + "Lean.Util.SortExprs": { + "relative_path": "lib/lean/Lean/Util/SortExprs.olean", + "sha256": "45a472f4dab7a0b1a22a2d5b07eac4e460c7a4471d49646f62e2d97d920faf6e" + }, + "Lean.Util.TestExtern": { + "relative_path": "lib/lean/Lean/Util/TestExtern.olean", + "sha256": "0c45aa686987702907d541dbe624dfb3b8c8389586d732fa05c9b86a53a96800" + }, + "Lean.Util.Trace": { + "relative_path": "lib/lean/Lean/Util/Trace.olean", + "sha256": "40e261ba920c89ca7a7573bfc699a3ac1e20983625025e2fc77a3aa8181a2c8f" + }, + "Lean.Widget": { + "relative_path": "lib/lean/Lean/Widget.olean", + "sha256": "82d3aaf72aaee748640ab3d5857f71623623455d4b4c7ac359f0f4e5e39a49f9" + }, + "Lean.Widget.Basic": { + "relative_path": "lib/lean/Lean/Widget/Basic.olean", + "sha256": "7b47ae225c065d669da84ca522e2dceb9a577e4bd7474d7377cf94d189a14ed9" + }, + "Lean.Widget.Diff": { + "relative_path": "lib/lean/Lean/Widget/Diff.olean", + "sha256": "6803e1c1d4d7de80fabd38cce68ecdabef3888f104d5b5bb17456a41a103ed6f" + }, + "Lean.Widget.InteractiveCode": { + "relative_path": "lib/lean/Lean/Widget/InteractiveCode.olean", + "sha256": "08dd8d5166eba1216188ec5a5b791c2e571805398fad6a4f0d1793026f063f54" + }, + "Lean.Widget.InteractiveDiagnostic": { + "relative_path": "lib/lean/Lean/Widget/InteractiveDiagnostic.olean", + "sha256": "a57b624487c0509b52919bf93ca49fd5006669cd87a28d7d1d6df05b7c121368" + }, + "Lean.Widget.InteractiveGoal": { + "relative_path": "lib/lean/Lean/Widget/InteractiveGoal.olean", + "sha256": "fe6f3299cefd00d81053c19c7a68a9140dd3c1199581807d18bc10212836b5b1" + }, + "Lean.Widget.TaggedText": { + "relative_path": "lib/lean/Lean/Widget/TaggedText.olean", + "sha256": "2231b307e81af9a860c445c61019110b50b2f7a147b20d4eff3a7aca896a495e" + }, + "Lean.Widget.Types": { + "relative_path": "lib/lean/Lean/Widget/Types.olean", + "sha256": "ec95be52006e362cdbab66493e159108d6b2803f7febb6f763d3e6ab58350a40" + }, + "Lean.Widget.UserWidget": { + "relative_path": "lib/lean/Lean/Widget/UserWidget.olean", + "sha256": "0e76215569ef9ba42148916c778a855b0eda47c384ffe95f40848401d3f7e77a" + }, + "Std": { + "relative_path": "lib/lean/Std.olean", + "sha256": "7d3771da25b893da62564bf8198487ff28f01af5cbd410be88d493a4921b2bb1" + }, + "Std.Classes.Ord": { + "relative_path": "lib/lean/Std/Classes/Ord.olean", + "sha256": "d951a4e6a043afe223eec3c1fc4ac05f4da95e923d7f9fa7438ccf1c4c5894e9" + }, + "Std.Data": { + "relative_path": "lib/lean/Std/Data.olean", + "sha256": "0c7214cfc515a6bd7d993a5a036a749d927911c61074e6f000b2f6e5c5e68437" + }, + "Std.Data.DHashMap": { + "relative_path": "lib/lean/Std/Data/DHashMap.olean", + "sha256": "82829a319d1dbc479d69cbeded2541fb6d4bea621843bcfb621dcddf66e3df4a" + }, + "Std.Data.DHashMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/DHashMap/AdditionalOperations.olean", + "sha256": "dcda48b215964eeb7adfdd6d8c898750cfdde669285b7e53559e844747be2e4f" + }, + "Std.Data.DHashMap.Basic": { + "relative_path": "lib/lean/Std/Data/DHashMap/Basic.olean", + "sha256": "3edd8593c538aa619f7a6a49b1201f895b2e195732067e9804cd1ec746ae0230" + }, + "Std.Data.DHashMap.Internal.AssocList.Basic": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Basic.olean", + "sha256": "cde6580d4017820217ba306c2850560e6c3820a22675b795bab7deee58fae39a" + }, + "Std.Data.DHashMap.Internal.AssocList.Lemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.olean", + "sha256": "89bb1625f83532972c2508e241727bd158ed8630437449d6dfb2409004029cca" + }, + "Std.Data.DHashMap.Internal.Defs": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Defs.olean", + "sha256": "b6789918a75b94e20a471fc1249196389b61a7bca005cb6e11868b9b2e0b2050" + }, + "Std.Data.DHashMap.Internal.HashesTo": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/HashesTo.olean", + "sha256": "df5a76c22a9d30d6067466a54454ffafb1d7a268ff2327e10d274d4b86bcb787" + }, + "Std.Data.DHashMap.Internal.Index": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Index.olean", + "sha256": "ca4d3761d5291eccc1f8238dafbe210fa5666c54a0a42c3e9b51acdcbe9d4900" + }, + "Std.Data.DHashMap.Internal.Model": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Model.olean", + "sha256": "dd3b5266f90bdc5e4cc8c5e9c1b65222671aaa830a5a23508f9fdb00fa6111c3" + }, + "Std.Data.DHashMap.Internal.Raw": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Raw.olean", + "sha256": "ab20c7d8f702c86de6cce3e18141f1297dea8d51a579460b0ddab9e278daf908" + }, + "Std.Data.DHashMap.Internal.RawLemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/RawLemmas.olean", + "sha256": "aa891b7b6476ead8295065dcd7df85e16c40e95a8a48c433d1e0c6ff8f58e9a7" + }, + "Std.Data.DHashMap.Internal.WF": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/WF.olean", + "sha256": "0d02c631912fd443890dd882c9035af450a64ded829c5613e29c6ad6d8690538" + }, + "Std.Data.DHashMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Lemmas.olean", + "sha256": "f5191f02349eb72c1ddb45074f9239912d9cd008a48a6cbabd76b2469d28d197" + }, + "Std.Data.DHashMap.Raw": { + "relative_path": "lib/lean/Std/Data/DHashMap/Raw.olean", + "sha256": "5ff8a7568a967e563bba428926cc128806c61ef2ecce021358984a45cff4c308" + }, + "Std.Data.DHashMap.RawDef": { + "relative_path": "lib/lean/Std/Data/DHashMap/RawDef.olean", + "sha256": "98e9e12f08790541143b32cfdaec3d0289209b1e770774dc01345116a7dddca4" + }, + "Std.Data.DHashMap.RawLemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/RawLemmas.olean", + "sha256": "514c964fac6f063724169db30add357a674ca243957dfa221e30430c26f06c92" + }, + "Std.Data.DTreeMap": { + "relative_path": "lib/lean/Std/Data/DTreeMap.olean", + "sha256": "51e3386cf7ba0a9f270c3a6d44af2ef5f6bac8fcffe8458cb7d3bba2edf610aa" + }, + "Std.Data.DTreeMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/DTreeMap/AdditionalOperations.olean", + "sha256": "a20b5c57a0db704748a2e2926dfa4d2cf1e4ddaefcc2245688970941c5ca8429" + }, + "Std.Data.DTreeMap.Basic": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Basic.olean", + "sha256": "26808eeb3d7d1e129af3a70fe13001b79dc74b18c7b406cb1373c7de98f62f56" + }, + "Std.Data.DTreeMap.Internal.Balanced": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Balanced.olean", + "sha256": "485264c582ccaaf76b6796dd881ccd1f6f61012f5d0c722fde5bd9a7b4310c70" + }, + "Std.Data.DTreeMap.Internal.Balancing": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Balancing.olean", + "sha256": "5263f1223026803115af0abbeeffdea7754796f215e6713aefc40c839b8353c1" + }, + "Std.Data.DTreeMap.Internal.Cell": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Cell.olean", + "sha256": "16fadb10f9bf8b6f4f20ec627775bdb827ff1f12c66b8e5f97c7e14b4a63ce98" + }, + "Std.Data.DTreeMap.Internal.Def": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Def.olean", + "sha256": "ad1d1e858fb304c03404a3003afefa2ab63634f240352448dbbe000fbc280ae7" + }, + "Std.Data.DTreeMap.Internal.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Lemmas.olean", + "sha256": "86f93dba7c263b8817d9a6e568d2a298b223b1dcf7a3bf63a21e04485d1e702e" + }, + "Std.Data.DTreeMap.Internal.Model": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Model.olean", + "sha256": "190a424ea72373859e33b93057f74fddfff1901c99020758c3b2a071893edcca" + }, + "Std.Data.DTreeMap.Internal.Operations": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Operations.olean", + "sha256": "02e3f14395f2e036d817076b3e901b7d186bd39c8b9e7204a1684faac1b5eaca" + }, + "Std.Data.DTreeMap.Internal.Ordered": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Ordered.olean", + "sha256": "bfd736cf4717c6dfd91e4764c030a2e35d7d80f24532ceccbb56924be30d3603" + }, + "Std.Data.DTreeMap.Internal.Queries": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Queries.olean", + "sha256": "4fb2bc063203c87f9db29252321a80602d0a7265647778abc9d22aaba5acbee7" + }, + "Std.Data.DTreeMap.Internal.WF.Defs": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Defs.olean", + "sha256": "899b439766bf2c13fba7b5ebfa6da9110b2e9f6e9ad9125c721d339332792432" + }, + "Std.Data.DTreeMap.Internal.WF.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.olean", + "sha256": "b6660199d8eaf0aaa0227cc92ef439c43914ff5f193983cb236d761212481a2a" + }, + "Std.Data.DTreeMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Lemmas.olean", + "sha256": "8f13b8ea4484f0112ac26021f999437da815203047e8d6dd398b3460616466bb" + }, + "Std.Data.DTreeMap.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Raw/Basic.olean", + "sha256": "d7ac0f19bdbd8fc3fbdeb86e07d5359234da8e0ead67247fb552613579747f6c" + }, + "Std.Data.HashMap": { + "relative_path": "lib/lean/Std/Data/HashMap.olean", + "sha256": "99aff9518169b47e1e93af220fb0526ff2a5ecaf538ff1bdd2962b6f2c8d4758" + }, + "Std.Data.HashMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/HashMap/AdditionalOperations.olean", + "sha256": "f7122016e852683cbe4b78252a5a0d334e31d8c583634068600988194a135753" + }, + "Std.Data.HashMap.Basic": { + "relative_path": "lib/lean/Std/Data/HashMap/Basic.olean", + "sha256": "6f76031eeeaa6d43db6e9c3a77c12f7811a80ac7d92b1538bd1b03c99e0588f6" + }, + "Std.Data.HashMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/HashMap/Lemmas.olean", + "sha256": "13da5f44c528a875968ebcab85fafb5cfc854b7f54fd4880ae6fbec2c8dd70d6" + }, + "Std.Data.HashMap.Raw": { + "relative_path": "lib/lean/Std/Data/HashMap/Raw.olean", + "sha256": "e22fdbb83c3274c85d0a292a3810c6408d134cf0d5e8bc0329f50777aee3e3f3" + }, + "Std.Data.HashMap.RawLemmas": { + "relative_path": "lib/lean/Std/Data/HashMap/RawLemmas.olean", + "sha256": "0a3c4d3b8e8d5ab3006148f6e227e5482da7199f8865c0c8dc762d07a13c71a8" + }, + "Std.Data.HashSet": { + "relative_path": "lib/lean/Std/Data/HashSet.olean", + "sha256": "ae45358a15acbf4ac5609305ab80d9ca42fa22cb4589f3c48c2a94a507250451" + }, + "Std.Data.HashSet.Basic": { + "relative_path": "lib/lean/Std/Data/HashSet/Basic.olean", + "sha256": "8bae54c3695a9aa1f51b76043d32ebbae9123b1a155605c54c1be2a899ce3385" + }, + "Std.Data.HashSet.Lemmas": { + "relative_path": "lib/lean/Std/Data/HashSet/Lemmas.olean", + "sha256": "29883ee4a5a8aceeef42dd000f1a3d682416b3668289b05afbb86cf3dbe7ed72" + }, + "Std.Data.HashSet.Raw": { + "relative_path": "lib/lean/Std/Data/HashSet/Raw.olean", + "sha256": "dc892a38a4976c064458b561027640cb3343c9661141c532c465f24bb635271d" + }, + "Std.Data.HashSet.RawLemmas": { + "relative_path": "lib/lean/Std/Data/HashSet/RawLemmas.olean", + "sha256": "ad52a319fb705c08ffd691126d42ee63e0e6a6caeb828114828cc2fe466f8db9" + }, + "Std.Data.Internal.Cut": { + "relative_path": "lib/lean/Std/Data/Internal/Cut.olean", + "sha256": "16e746f9da7b0e74567b1656a7e3f99cafc699acc54faed11bbe17a02d801060" + }, + "Std.Data.Internal.List.Associative": { + "relative_path": "lib/lean/Std/Data/Internal/List/Associative.olean", + "sha256": "fec662ce7c583a3d835d612b39ec478a6153c06e3b7de30a537cf6895f5bb093" + }, + "Std.Data.Internal.List.Defs": { + "relative_path": "lib/lean/Std/Data/Internal/List/Defs.olean", + "sha256": "56e8ec040898820fa1f1b9d807be6c96e4c44812b61c37b29ba4eb92199dbbc4" + }, + "Std.Data.TreeMap": { + "relative_path": "lib/lean/Std/Data/TreeMap.olean", + "sha256": "a1acd79ea550bcbeb8803a663d203d65c2ec5f3c528e1d3b20e6d84bba1f5818" + }, + "Std.Data.TreeMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/TreeMap/AdditionalOperations.olean", + "sha256": "7ff677628c427286ffa273bb5e733ba2b3c400ba4ac199377d8f354740bd90d5" + }, + "Std.Data.TreeMap.Basic": { + "relative_path": "lib/lean/Std/Data/TreeMap/Basic.olean", + "sha256": "01d1578d10e52b69cfa9a2ebc0dbbb16dd36a786deee2bdf44129b2672f67755" + }, + "Std.Data.TreeMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/TreeMap/Lemmas.olean", + "sha256": "c6b1f9d219326bf24700910e14066001120a278f007001bbf2a32dedd1af4006" + }, + "Std.Data.TreeMap.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/TreeMap/Raw/Basic.olean", + "sha256": "bc2fb5d7aa288ceb2d373f3c6a66c016a439cd1eb5560ba2a641e835064c833e" + }, + "Std.Data.TreeSet": { + "relative_path": "lib/lean/Std/Data/TreeSet.olean", + "sha256": "14078e4b78360b5431a4232dc911486455591bff1a3fad55f9155ae8c2ad7cac" + }, + "Std.Data.TreeSet.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/TreeSet/AdditionalOperations.olean", + "sha256": "86a8774587ec420050092ce6ba115aa9d379c59b491f55c815c062fdff15ce73" + }, + "Std.Data.TreeSet.Basic": { + "relative_path": "lib/lean/Std/Data/TreeSet/Basic.olean", + "sha256": "8f725039367c3acfe7a9de41011ce1bf66cb375fb16a0b4468d414c2f0ed5fc6" + }, + "Std.Data.TreeSet.Lemmas": { + "relative_path": "lib/lean/Std/Data/TreeSet/Lemmas.olean", + "sha256": "c436c982509e245de849ae7ca0a437b7f08eed26cd7a3eccc926763acd3fe9fe" + }, + "Std.Data.TreeSet.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/TreeSet/Raw/Basic.olean", + "sha256": "e970f9894439ef66418424f9d769c9e76de5ed0a6443c90dd821b482d715d015" + }, + "Std.Internal": { + "relative_path": "lib/lean/Std/Internal.olean", + "sha256": "450df0e4fd6e36bd632bccad2663e04b615dbba865e59de53815dd54bc5d3c1f" + }, + "Std.Internal.Async": { + "relative_path": "lib/lean/Std/Internal/Async.olean", + "sha256": "01ffdfd1f0410911338f8ef8b7e5f403d875b1a38ed01eac1953cd9c1659e3eb" + }, + "Std.Internal.Async.Basic": { + "relative_path": "lib/lean/Std/Internal/Async/Basic.olean", + "sha256": "77e5e714a1a50a1c66d738574d61b94729fa505d928f4041b479220c35f926d2" + }, + "Std.Internal.Async.TCP": { + "relative_path": "lib/lean/Std/Internal/Async/TCP.olean", + "sha256": "b8d4d89acab2bbb45c8f0ae41f0d43a9d1978efdbbf3cce9d21a8adbe977fbf2" + }, + "Std.Internal.Async.Timer": { + "relative_path": "lib/lean/Std/Internal/Async/Timer.olean", + "sha256": "df2a28402222a5529fe6c5d506b96d8b1a11a9a5722456590e77be97fe7bd59f" + }, + "Std.Internal.Async.UDP": { + "relative_path": "lib/lean/Std/Internal/Async/UDP.olean", + "sha256": "42aaaef54fd0324c3160d18901df6ab67d12c1392a5f7f79764e4b8ccdabef84" + }, + "Std.Internal.Parsec": { + "relative_path": "lib/lean/Std/Internal/Parsec.olean", + "sha256": "847cdbecf06faf5fc1ec0a8edbda87e56cae864215c3e5b0794e4487e52991e5" + }, + "Std.Internal.Parsec.Basic": { + "relative_path": "lib/lean/Std/Internal/Parsec/Basic.olean", + "sha256": "5043a60429010c81f150397f937633e38e59a4ebb0fedd362a3c4326d4c9e70c" + }, + "Std.Internal.Parsec.ByteArray": { + "relative_path": "lib/lean/Std/Internal/Parsec/ByteArray.olean", + "sha256": "b83f1320328c2ad431534ac41512842f4d99059c8ffce50cfad5c323f5d05bcb" + }, + "Std.Internal.Parsec.String": { + "relative_path": "lib/lean/Std/Internal/Parsec/String.olean", + "sha256": "d8fb53b268a2d7ca6b26a14028a6e2a396063d3c747373aca64f18bdafbcdd82" + }, + "Std.Internal.Rat": { + "relative_path": "lib/lean/Std/Internal/Rat.olean", + "sha256": "63e1219fe06b26b0022abcebc49b641a8726d1ffcb43650b6afcb61af71ef85e" + }, + "Std.Internal.UV": { + "relative_path": "lib/lean/Std/Internal/UV.olean", + "sha256": "510f7cfab3bf9547fe3bce0dd31453b8521ed3b7b25beeb16ee88bb088c90e60" + }, + "Std.Internal.UV.Loop": { + "relative_path": "lib/lean/Std/Internal/UV/Loop.olean", + "sha256": "732dc39b26fbc6027819191475f9aade211b5995be9036bf0babd80d2740d09e" + }, + "Std.Internal.UV.TCP": { + "relative_path": "lib/lean/Std/Internal/UV/TCP.olean", + "sha256": "dadd785a07060659ba22f37fcb6e17a06af3b6140d200e7d8f223ae7aaf928ad" + }, + "Std.Internal.UV.Timer": { + "relative_path": "lib/lean/Std/Internal/UV/Timer.olean", + "sha256": "57cee1e20bf5d037bcf6afe9720488ee00720e2deb2ce05d0445d4e097fc27b1" + }, + "Std.Internal.UV.UDP": { + "relative_path": "lib/lean/Std/Internal/UV/UDP.olean", + "sha256": "29d41d16510671c81a1df5b46e75f8c61c0ecce2ee5b35e53737bdc724022b2e" + }, + "Std.Net": { + "relative_path": "lib/lean/Std/Net.olean", + "sha256": "4c3e86bee81a4336a0aa64a3be9467a20b8b738bd1a8924ee4df82b980a0e4a2" + }, + "Std.Net.Addr": { + "relative_path": "lib/lean/Std/Net/Addr.olean", + "sha256": "21a68252d88ccc4e33691b2cab7aef5cc7cc8881c4e7a00e2154c4db8635492d" + }, + "Std.Sat": { + "relative_path": "lib/lean/Std/Sat.olean", + "sha256": "fcc29fb616396ddc2d3047d9b5c2f8dd3ad6239d727e06edfa2273e11f22109c" + }, + "Std.Sat.AIG": { + "relative_path": "lib/lean/Std/Sat/AIG.olean", + "sha256": "7c6aea2cf4f55d3ea5b3b4ae186869fcd416cb24fc5b1c797bf2aa511ced7207" + }, + "Std.Sat.AIG.Basic": { + "relative_path": "lib/lean/Std/Sat/AIG/Basic.olean", + "sha256": "97590c68ccbef54da03f6ea927368d999b560f594840a2c2c3899e52602a2a19" + }, + "Std.Sat.AIG.CNF": { + "relative_path": "lib/lean/Std/Sat/AIG/CNF.olean", + "sha256": "38e7324f561c93510b5b42466fc3b60be8372a46e0b872a45678fd6dc40c8495" + }, + "Std.Sat.AIG.Cached": { + "relative_path": "lib/lean/Std/Sat/AIG/Cached.olean", + "sha256": "f9b8e7536aaa9f2663fb19cbfddd1da6c0c9d1035b79ed5f71acea3ed76a913f" + }, + "Std.Sat.AIG.CachedGates": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedGates.olean", + "sha256": "a9fba0492584b3e3e537f181e626be94d5ff4d4f7cdfb6193d0ebfa59619fb03" + }, + "Std.Sat.AIG.CachedGatesLemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedGatesLemmas.olean", + "sha256": "e7637f2f0f2df05851138dc94f305c976aca8fbd121f648afae1b1be75edf072" + }, + "Std.Sat.AIG.CachedLemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedLemmas.olean", + "sha256": "4e8c65e9bc960950ea123ee30c9434b1e7a31955db5c6b118b5f6d1bf91b4151" + }, + "Std.Sat.AIG.If": { + "relative_path": "lib/lean/Std/Sat/AIG/If.olean", + "sha256": "0a976606263c24d96f678d34322b1172ee3ae1c1f50c9bc25274411b99ddbb21" + }, + "Std.Sat.AIG.LawfulOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/LawfulOperator.olean", + "sha256": "c8467c1aee8523a9b728ccf79988145304cada06f1da7eb80324db331aec8728" + }, + "Std.Sat.AIG.LawfulVecOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/LawfulVecOperator.olean", + "sha256": "2bcfabf0755288b3c3099a16e615e0e7e474c9b48e705ebee28137a46c4c6768" + }, + "Std.Sat.AIG.Lemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/Lemmas.olean", + "sha256": "0056f8de120614c48889fe5157b0fa5eb4e5caa87c1300a46d6f412268baf65d" + }, + "Std.Sat.AIG.RefVec": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVec.olean", + "sha256": "e8de7999a97a5390370aec10715a77d3abaf292a7df37a584c06e706458284ae" + }, + "Std.Sat.AIG.RefVecOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator.olean", + "sha256": "c07b62713579424613487ed5f40318b44cd5a30036959d23e9c7a39256c9474f" + }, + "Std.Sat.AIG.RefVecOperator.Fold": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Fold.olean", + "sha256": "8c65d0c2a25e424866314efd53a4edc08c2cd9da55edb76034538969fa3db5bc" + }, + "Std.Sat.AIG.RefVecOperator.Map": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Map.olean", + "sha256": "569cee3ddeb7b1b314354d0f051052bc4d21919d3948c06eeaba5da15f9dac96" + }, + "Std.Sat.AIG.RefVecOperator.Zip": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Zip.olean", + "sha256": "94244a0a8f0ce753f93b64831b56577cd9b8d68f9131b278281b77a3f2d43d44" + }, + "Std.Sat.AIG.Relabel": { + "relative_path": "lib/lean/Std/Sat/AIG/Relabel.olean", + "sha256": "fbdc72b958646b6206f8fd36cac01472e075dc69705f33947bbbef6614b6aa8b" + }, + "Std.Sat.AIG.RelabelNat": { + "relative_path": "lib/lean/Std/Sat/AIG/RelabelNat.olean", + "sha256": "8d7e0ea32786d8ce69c8605df88c666dbf8dee641c7945fde40e302ce7051a9d" + }, + "Std.Sat.CNF": { + "relative_path": "lib/lean/Std/Sat/CNF.olean", + "sha256": "a7ad1ae81e0305e03e2b6f3827101cde4cf4da0b64a59b3a25c038c4661ddc77" + }, + "Std.Sat.CNF.Basic": { + "relative_path": "lib/lean/Std/Sat/CNF/Basic.olean", + "sha256": "9fd3c6545ed9a1cb8b606df1749d7e40eb4eac6932fd19ad0efbbaaef98534d4" + }, + "Std.Sat.CNF.Dimacs": { + "relative_path": "lib/lean/Std/Sat/CNF/Dimacs.olean", + "sha256": "d35723222970cd0c95eccee2d1c8d94aef51ab955c1b8f35eb024fc395f664b4" + }, + "Std.Sat.CNF.Literal": { + "relative_path": "lib/lean/Std/Sat/CNF/Literal.olean", + "sha256": "86f2a80fe2c28b8e831989e13154f772a51fe820bca3ea61c5a542a56b0eef6d" + }, + "Std.Sat.CNF.Relabel": { + "relative_path": "lib/lean/Std/Sat/CNF/Relabel.olean", + "sha256": "e9bb76081b5ecf50ee4b6dd88e99f9cf405dc77574772c8645fd5f43d4310ec3" + }, + "Std.Sat.CNF.RelabelFin": { + "relative_path": "lib/lean/Std/Sat/CNF/RelabelFin.olean", + "sha256": "5b23bd94880be12c59a33437f57c82873234d547a0085a29c6dc4ca37f304ab2" + }, + "Std.Sync": { + "relative_path": "lib/lean/Std/Sync.olean", + "sha256": "6b122caecb73d049b18ea82b184696b04898758dea48f62c7e8b0ec17068c34f" + }, + "Std.Sync.Barrier": { + "relative_path": "lib/lean/Std/Sync/Barrier.olean", + "sha256": "0865e927b2d5c74eb1e762ef6043b19db015a3f7a16997392bdbe3405616c9e6" + }, + "Std.Sync.Basic": { + "relative_path": "lib/lean/Std/Sync/Basic.olean", + "sha256": "0ab37aae226de3c3c249e48eb99348220fd9239db043e8e70b00491ca7df6ffb" + }, + "Std.Sync.Channel": { + "relative_path": "lib/lean/Std/Sync/Channel.olean", + "sha256": "d263a7b5e81f7d062701d56c2f2940ec728e0b45d42ae29ac7ef5ad174b17a0f" + }, + "Std.Sync.Mutex": { + "relative_path": "lib/lean/Std/Sync/Mutex.olean", + "sha256": "28b1da9b8ad2e7873573ef3a394c20fbb1483b145dea927e22ae760913dfd30c" + }, + "Std.Sync.RecursiveMutex": { + "relative_path": "lib/lean/Std/Sync/RecursiveMutex.olean", + "sha256": "e270bb327da588a077b986c6683149f93c99ed2e43f2b80cdc79bf3255118fe5" + }, + "Std.Tactic": { + "relative_path": "lib/lean/Std/Tactic.olean", + "sha256": "bc4cb70f826910d0d63d5bb519966d715681e8fe8fb73913796d9c51c8530d7d" + }, + "Std.Tactic.BVDecide": { + "relative_path": "lib/lean/Std/Tactic/BVDecide.olean", + "sha256": "ec2db6253a2c5adbe13b53fdf97893e62022706a3a1604ade21af796ae949a17" + }, + "Std.Tactic.BVDecide.Bitblast": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast.olean", + "sha256": "faef1612ce3f38d3fa7978cf6b303d9876bbd43837dab7bfc0d7df30a42a1f86" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.olean", + "sha256": "36c4f0fd074cd62290da4cd5d0dd25b253108e7b37927836a2a68e24cbc62611" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.olean", + "sha256": "3fbf55b92e7fa7459b5626803a5c28693f10ae22bcc07dd0bbd5f9e52ddd5fc4" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.olean", + "sha256": "dc870f512d9db277c5e04837974578471b7aa8b6d7cd20c2e349c9f55776fde1" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.olean", + "sha256": "2bc70c17d6a23ed6d2b67e0fa0c46a2cde4b41fa6aec824dc64f609a81f8076b" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.olean", + "sha256": "28690113394104f6b0bf446e71254522b38e370ad8b4c48d2643c3c251f117c4" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.olean", + "sha256": "f831b1544b66b6c04562548d8ee3cd406faed9171e989001d235ca22489d93de" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.olean", + "sha256": "00399f76c92cefb3439614ef294998f337e72995b6279c7f3f57be5a182f3952" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.olean", + "sha256": "9fc172f017a8e08b3d373edb60be3aba9e3d82854acee27bb757e2052b7a073f" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.olean", + "sha256": "ba59db26788faeb05b026dd06ba5ddb8b39cb9169110413fa6ad5d65a1782f43" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.olean", + "sha256": "296f54c53ddf18f21dd6dbc6e279ba7256b944e35ed130570288d2fbc1bbafd3" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.olean", + "sha256": "4391a259589f6be7008648b4ab9eef743dc2b9a74f0f7dd4d631d534b8811e17" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.olean", + "sha256": "c87ee1a5d918eeda72930bbcf4889d9402a09bfe286b25012b06efac778dafbf" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.olean", + "sha256": "69116d9ffc41a4f37932d8cb3b4cea6592b9bda6f583df045b0f30ae0ec4a878" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.olean", + "sha256": "1c3439af37c32110c822bfee7afdf8b82289219f223e4475a61a2930876c270d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.olean", + "sha256": "bdae571ecb63fcd2e404c549d0233645f1d49daa257b854c03fdc672b11f25fe" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.olean", + "sha256": "6be36fe5e846df460b9cafdce7ce00525a16032b0f9957ef269429e4bc3235ce" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.olean", + "sha256": "2af3d46c89c1184b87d0499f08ae1364ede6b4d45a682ecc84a646c6ff37b590" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.olean", + "sha256": "59df5f0bdf0ab63f1d3a70c1ec428b51cd4d272aedd17ff6e69a47c8043eeb90" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.olean", + "sha256": "1c55bdc3550f4476aad8e2aabd64211d69c8993514758e2af3cc2251769b138e" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.olean", + "sha256": "f13b326a06e1000c0515520d0f4899e1aff23420f0e0e6ac5bba48a7a2061741" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.olean", + "sha256": "102946d64852967c3f451a662c10e0a548bec046e621e551b7dc467e4a0a2d7e" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.olean", + "sha256": "5f58293f58319935148d7a2bc68ad221ce9f5af0083862d72aece51381358100" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.olean", + "sha256": "5d0b577707c12577db272d62533ff29b2c37eca1ea425df4aaf104e74082ce1d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.olean", + "sha256": "0557dd76c0b555d978d97d7f04bc178ebb786d428871e4dd3cd73445f8bd2c39" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.olean", + "sha256": "81ba89dd877e8f5ecb4d79795d720bff671a1c226354759b28fab162f38e46ff" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.olean", + "sha256": "ebc829c16a69ba4601c7173f03eec5532020c0cff7ae92cd6dbcefd0368c2697" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.olean", + "sha256": "a4303ebf7a2e9d22270c2838e6240c06b563518adb9d4137349db1777b96ba86" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.olean", + "sha256": "3a8c2f39f7bf1f389bbd88e0e960d34ecf4b7af474a15d3669a397fe63a3b687" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.olean", + "sha256": "d67ad63ce049fe122cf9772ed2782555c6616ac326f67426e153f6cd5f5f31ea" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.olean", + "sha256": "308ad2bec762bc6ba6dd20c8a59466369dff6f12baed0014502ceb9af81f9128" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.olean", + "sha256": "c594d47b6dd7831dc6fbf18f337e4beb8cc317596d4da513c74cdd590b2aaa82" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.olean", + "sha256": "0e83560f33741e683d83de2c88d3b9bea126b818d4f9b947b6e2e60f3273793a" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.olean", + "sha256": "f4afff7bfa61967afcddcef49102e8aa6abfb46ac719f45fae9b2929995939df" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.olean", + "sha256": "57f9283128ba0708949930c0919ecadc22ec7b9d7e6b2dcdd7fad92a736afe0d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.olean", + "sha256": "35d396442771affa7630a0347396755620f9d042e8d489514dbefa2e5f3bd3ef" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.olean", + "sha256": "61ab83020b62ecea43b39fb36d24b2c6264f101c300bc53a020e29ac5cf23202" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.olean", + "sha256": "561125bbfaf3f343d17e25d37d77e43cfd0eaf6e21e0017cc9112929162d6628" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.olean", + "sha256": "cc8b989993b821ea578bb842b8da6c80522df6826b6d01238ca5adb568e449ac" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.olean", + "sha256": "d3072d202bf75c36371af08a4299d2982ad51392353d92d5011357964e3cd384" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.olean", + "sha256": "2be5439ac28922644312c8f8299059f81e58c79741d3a681a8a14a83457649ab" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.olean", + "sha256": "5b894fa82377d826b231e52d38987bf71fc1b10a92a7955fd18d9e5e5ebfe7ec" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.olean", + "sha256": "b2ac78762a87a6575421fda19f6576adf93e93f0b1af4b0ce49f55b8e9064463" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.olean", + "sha256": "0c5587d74b82923fd948c50d3da937bab12b86ec827d5e560c82b35bfa5c68fa" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.olean", + "sha256": "b95d38b7d0aabf70cb06123400e6ba0b94fd6073228b0eb5f55ab97d4428938a" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.olean", + "sha256": "789048c3011f067a8b8fba24630807fa03ce445f9e3dfac8c3528a4456603265" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.olean", + "sha256": "3dcc31a71f38e23ac8977a6e457302b32f5bcebde968012f3c33719e6b9c14f3" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.olean", + "sha256": "b5f8825d43310fb7f7333af20149f3064337396bafef7011d8af55c7f90380a5" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.olean", + "sha256": "8d9ff31e861a653c4998376235a1bfd1dcf760f05e1500f9867180cefd020d8b" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.olean", + "sha256": "10d1d3835811dde10bb29ad96b6c897780d8560198b0d04f28d1c3e4f4be1205" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.olean", + "sha256": "41ca8e8480c53c66991bf6dd267aa6bcd8d7c347942dec93d11b85f8d7224555" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.olean", + "sha256": "b2d68c645229bcfff4c1cb5d536e6acc7cb924ee954f9632198d5039280cd446" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.olean", + "sha256": "76828daa75f4568048da7ae525f1da9927112b9ea96ec22385387e2dcc0d1cbe" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.olean", + "sha256": "1a87afbf4654899ff46aed23db3f6ee24775b3113f551d4b1fb1e4e055b4968b" + }, + "Std.Tactic.BVDecide.Bitblast.BoolExpr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.olean", + "sha256": "3ab631e587fb4f4a5fc155f91d705d3ac544f98c75b22313db962ae0fcd9ba26" + }, + "Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.olean", + "sha256": "d441ce6550ac5d66fa7fed9d2f1b2e6a7207a0aa82d82da4ea372b2a4fad5526" + }, + "Std.Tactic.BVDecide.LRAT": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT.olean", + "sha256": "d355212d6f59c522d94e3c3dd34e3a02d74584f21270d3c75fd0f7b0fc1e6b23" + }, + "Std.Tactic.BVDecide.LRAT.Actions": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Actions.olean", + "sha256": "0077323c22e78b14dd46684d812da596c363a8f835ab47d9b7b429edcaf77c6f" + }, + "Std.Tactic.BVDecide.LRAT.Checker": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Checker.olean", + "sha256": "24cd2c42a4f2f34ecb83b2214194c9c808c7cc2ae49763f785d66911fb791e64" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Actions": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.olean", + "sha256": "6a8d16b5f258b9da457a8dae2729cf9cc8184ae3770c62c7767b60610d12cbf2" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Assignment": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.olean", + "sha256": "1dc4cf78bf8dd9093f22e8fb31fc2585a676096e1f92d8a169853e8c32e27868" + }, + "Std.Tactic.BVDecide.LRAT.Internal.CNF": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.olean", + "sha256": "5b09536fadc7ad28c0597d86a2926cc69397fbf93011a53ec07f3bc5d8144527" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Clause": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.olean", + "sha256": "c0ee4492b32ab35324ba3aa234288a517bbfd1a057b55a12b5587579dc8de5e4" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Convert": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.olean", + "sha256": "644f9516699727499c6bbf434dc411c7e32be39727c27df9fcf4ac4bc7885dfd" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Entails": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.olean", + "sha256": "555bd01a87e35f742a6784327cb0e15caa4b4589fdcb23b7d156612c8359aa60" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.olean", + "sha256": "e402782d59c498b9098addaf51b65c2a1f76015a3626d11ab150c7f8e4525e3c" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Class": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.olean", + "sha256": "61faf33007eb81ff1ba8c12c4829d6b8353b52580d1ae32216c5acce24117930" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.olean", + "sha256": "d8d956c48977e92718e15f51f3ed0e37b2523e84129f48c93d738a5ecc73e598" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.olean", + "sha256": "02dc2826a248aba00b4ff538bf73d1e84a1d26cb6bd86878e9aeaf96911578ea" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.olean", + "sha256": "326b363db75185b4e385f6d5ed25e3bc52249695cd47e96f7291b2befc17d99d" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.olean", + "sha256": "c8ae044e3f0cbfbdd16a5c8776c5bb505b8edecd7caa7227ac3e268f8e5a813b" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.olean", + "sha256": "f4639e7f4ce1257677cb3ef954622a378c51facaa49d1c2033d655a0429854ee" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.olean", + "sha256": "3db7edc84442cd86d9688f0259a59868e76ed0759f2d86dd35da5b8e928fecb5" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.olean", + "sha256": "7584cffd13ae359e9c7ef8edaea45c6d0233fbdcee5d80ee57aa9ac5284af5ce" + }, + "Std.Tactic.BVDecide.LRAT.Internal.LRATChecker": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.olean", + "sha256": "adad26830176d3fbb2cbd64c83197f5083e196b2a2651ee8d7194512724770da" + }, + "Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.olean", + "sha256": "b21dfacd5f2e5488e49885bfcf7de9deeb429a3c12a9a5d595f9f118372e8f90" + }, + "Std.Tactic.BVDecide.LRAT.Internal.PosFin": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.olean", + "sha256": "c9064ca9acae028a144600c48c49583991419d743274fc91d3bc6033e5f647a5" + }, + "Std.Tactic.BVDecide.LRAT.Parser": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Parser.olean", + "sha256": "99c91ddf2e3209427989057505c6db8ae009b0b66473add1123091e82eae22d5" + }, + "Std.Tactic.BVDecide.Normalize": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize.olean", + "sha256": "5a32966bb5d1d044ebbfa16701971c19613410077471fd78907932d23ac9d896" + }, + "Std.Tactic.BVDecide.Normalize.BitVec": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/BitVec.olean", + "sha256": "9a5419dace60a2336218c9900ccc2ba5b1740ee3ad3395204c1db96e2ee1265a" + }, + "Std.Tactic.BVDecide.Normalize.Bool": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Bool.olean", + "sha256": "e4a7ad5bb1aa46632d4f53c2e534df650adbab5d2299ab05f9357bf814568c02" + }, + "Std.Tactic.BVDecide.Normalize.Canonicalize": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.olean", + "sha256": "42efde7852aa32bfb49a2096a017f1acc3de2be1843f9a766fc33a2e8dba6ec9" + }, + "Std.Tactic.BVDecide.Normalize.Equal": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Equal.olean", + "sha256": "b811a7a95c0f5e441dfc6b4cefb0eec03e237442d2c57224fa4cf498436be742" + }, + "Std.Tactic.BVDecide.Normalize.Prop": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Prop.olean", + "sha256": "299264cac5f784ffcb12d7ec211033cf7913c4470e7ff363ade0cbbd2f18ea9a" + }, + "Std.Tactic.BVDecide.Reflect": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Reflect.olean", + "sha256": "6fa2f9828a59c1674437bee299f112a673ce7a30add77784b2bb610b6fdb50c6" + }, + "Std.Tactic.BVDecide.Syntax": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Syntax.olean", + "sha256": "0359dc3655c79f41a47af4d3c87485f738b79ac032d59738bbf48e16027416ba" + }, + "Std.Time": { + "relative_path": "lib/lean/Std/Time.olean", + "sha256": "0789687baa3558734be38cc4d152d748e9c6d2edf399507a1976246ce1db15d9" + }, + "Std.Time.Date": { + "relative_path": "lib/lean/Std/Time/Date.olean", + "sha256": "cb70aed3ccf7127c906dcab116c95c522aecb3987140814941c84eae42bf3f2a" + }, + "Std.Time.Date.Basic": { + "relative_path": "lib/lean/Std/Time/Date/Basic.olean", + "sha256": "f307e1a552373d28301792b5ca8bd0110b8e9d93eb81575689fbe3efd52b7ed8" + }, + "Std.Time.Date.PlainDate": { + "relative_path": "lib/lean/Std/Time/Date/PlainDate.olean", + "sha256": "9e9df12ccb5c285114cfdcf4039a2a021614747c9c45ccb6995722d248ddf3bb" + }, + "Std.Time.Date.Unit.Basic": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Basic.olean", + "sha256": "a073a7513d6b1fd55d88c56f341a3db71a933ee0563334e869db0e51618648f7" + }, + "Std.Time.Date.Unit.Day": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Day.olean", + "sha256": "5ebf7bb099376860bc2f18e7301dc33b2fba23a8de092dfa4ccc540a607edb1f" + }, + "Std.Time.Date.Unit.Month": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Month.olean", + "sha256": "795840aeee04727bd136c09d6f7c57c5eab32967bc5baa642caa071700d6f5ba" + }, + "Std.Time.Date.Unit.Week": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Week.olean", + "sha256": "1af7b14f7241b1157f7ede0be10b1ce8f84d59629fe9256ef2853f93f9920d10" + }, + "Std.Time.Date.Unit.Weekday": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Weekday.olean", + "sha256": "58a27e1054c0f7083540030928455a2f7f89568fd4df27904a992312e540431a" + }, + "Std.Time.Date.Unit.Year": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Year.olean", + "sha256": "1429b88657ba6078d953466050ae379a2c0ad32f908e64d3791b3f91271ab506" + }, + "Std.Time.Date.ValidDate": { + "relative_path": "lib/lean/Std/Time/Date/ValidDate.olean", + "sha256": "ace3749ecca5141ab1d66312455cbc165abe4a5e2a92e99181bdcab5a45dcaf8" + }, + "Std.Time.DateTime": { + "relative_path": "lib/lean/Std/Time/DateTime.olean", + "sha256": "bace36aa9c50b519ee6e46e6489fdfe349e77b3f7f00e952b8ddc54361639811" + }, + "Std.Time.DateTime.PlainDateTime": { + "relative_path": "lib/lean/Std/Time/DateTime/PlainDateTime.olean", + "sha256": "1296dc0c67ac54dbc5d0b1977fcfff082655daaea079ba088c070cdc4890924c" + }, + "Std.Time.DateTime.Timestamp": { + "relative_path": "lib/lean/Std/Time/DateTime/Timestamp.olean", + "sha256": "b4cd23a2f4ea4c96f2df2b83cfc655d0e19bef0238f6c044bf37b417faeb8756" + }, + "Std.Time.Duration": { + "relative_path": "lib/lean/Std/Time/Duration.olean", + "sha256": "768a81cc06f2a7b70728d660889a4e243f0fcfcf9270cdf735c7f95a26775a81" + }, + "Std.Time.Format": { + "relative_path": "lib/lean/Std/Time/Format.olean", + "sha256": "8d0928fbefb93f6de1f46e7e622f86beadb3e27115a29880eb0745b6fd74b7d4" + }, + "Std.Time.Format.Basic": { + "relative_path": "lib/lean/Std/Time/Format/Basic.olean", + "sha256": "23d409ed591814fd515cfb89781c282bf1990635241a8dac0fe4aa40668ce135" + }, + "Std.Time.Internal": { + "relative_path": "lib/lean/Std/Time/Internal.olean", + "sha256": "aecafe702fdd9d7c770b6b7d4d1843616ed03470014b13ea1ffc0d376c8091f0" + }, + "Std.Time.Internal.Bounded": { + "relative_path": "lib/lean/Std/Time/Internal/Bounded.olean", + "sha256": "49de757e44969f7b58b61b2218ba797db7d82682f64e272a249ffa13cec52d06" + }, + "Std.Time.Internal.UnitVal": { + "relative_path": "lib/lean/Std/Time/Internal/UnitVal.olean", + "sha256": "2293196364e88707f8cb1d82e99a18f155630a82a60f1ea6399f0144fdb6ef3f" + }, + "Std.Time.Notation": { + "relative_path": "lib/lean/Std/Time/Notation.olean", + "sha256": "9e9cd56d4bb18752d074d9a5545677bf880510f07038ad29595c0d88754b21c0" + }, + "Std.Time.Notation.Spec": { + "relative_path": "lib/lean/Std/Time/Notation/Spec.olean", + "sha256": "a08aada50626422dffd9168eccc354a0dda7769fc33d943c48d5c6dbeba380dd" + }, + "Std.Time.Time": { + "relative_path": "lib/lean/Std/Time/Time.olean", + "sha256": "aaa5e2da3807c23c60e80153e6a683af0835a58d89805dfb52cf9cfcdd09599b" + }, + "Std.Time.Time.Basic": { + "relative_path": "lib/lean/Std/Time/Time/Basic.olean", + "sha256": "08e7ff82d05c4f4aa49fc9b0702a1d499f31334df58a4dd693c92cf1860f50e8" + }, + "Std.Time.Time.HourMarker": { + "relative_path": "lib/lean/Std/Time/Time/HourMarker.olean", + "sha256": "be5bbcafbc86d200ae38d3681fa62eb89c5f92e54e658ce926f535a4ea5b7821" + }, + "Std.Time.Time.PlainTime": { + "relative_path": "lib/lean/Std/Time/Time/PlainTime.olean", + "sha256": "c341b0c38877ca56f7b8b758947b2e4cbe2cc5818286d78c4cb7d7f08fe60580" + }, + "Std.Time.Time.Unit.Basic": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Basic.olean", + "sha256": "d9802ce1313c896333ee3ad31889057c81f13bd40510da853d711018eb82deee" + }, + "Std.Time.Time.Unit.Hour": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Hour.olean", + "sha256": "cd26a34fd6964178efcfa29c86f9f240bb61dd601ec6e8a4daaa4fa1aeae1085" + }, + "Std.Time.Time.Unit.Millisecond": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Millisecond.olean", + "sha256": "f276ecae1131a214858236a4e6e3f495fc7e01d551d3b0bfa98c18301dea92f2" + }, + "Std.Time.Time.Unit.Minute": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Minute.olean", + "sha256": "7c9dc59498474221677908f899f8f8b98ccc4bcb9ced0a76b4b73608e03d1cb6" + }, + "Std.Time.Time.Unit.Nanosecond": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Nanosecond.olean", + "sha256": "6bc08672ed7d3e38d0343ce320ae09b2022fe6dab7e13c589dd11a12f6761147" + }, + "Std.Time.Time.Unit.Second": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Second.olean", + "sha256": "19a8c2259f0d51723c508d313c5d2da2896a5af464e9d6c809e047a772d49969" + }, + "Std.Time.Zoned": { + "relative_path": "lib/lean/Std/Time/Zoned.olean", + "sha256": "84ada81b95c5f170f68d7d2ec234bd3d007ad45d18364e531e5307f2c4d32617" + }, + "Std.Time.Zoned.Database": { + "relative_path": "lib/lean/Std/Time/Zoned/Database.olean", + "sha256": "5a324870d1bb5c102a79717c53840bb87ebbe4c7afb03499a31fb7aa51e04e8f" + }, + "Std.Time.Zoned.Database.Basic": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/Basic.olean", + "sha256": "76d13490a9d782e3c2616634c1d450f81d7978f836d5b7e6969361297a0287c9" + }, + "Std.Time.Zoned.Database.TZdb": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/TZdb.olean", + "sha256": "3345c6282c8805f291bfe6a6c219d4f8d21a2ab8aff2ad46e169aa33c073f777" + }, + "Std.Time.Zoned.Database.TzIf": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/TzIf.olean", + "sha256": "8fe12d507111f7ec04b7d1594959d190604da5bb3a0d944101472cedc2f4da02" + }, + "Std.Time.Zoned.Database.Windows": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/Windows.olean", + "sha256": "50d1a55ee0a71ddf05198a448f019c2bab95dab5d0e930157c220b8d349cbbdd" + }, + "Std.Time.Zoned.DateTime": { + "relative_path": "lib/lean/Std/Time/Zoned/DateTime.olean", + "sha256": "d313bdaf5fdefdc120eb57b5736d495d60ff33febf26db330e1fd99a7a2c396c" + }, + "Std.Time.Zoned.Offset": { + "relative_path": "lib/lean/Std/Time/Zoned/Offset.olean", + "sha256": "41d7f3f24b83359a4da791ff9d6e390bc19a09d0335086be6ac37b809ec75e5b" + }, + "Std.Time.Zoned.TimeZone": { + "relative_path": "lib/lean/Std/Time/Zoned/TimeZone.olean", + "sha256": "406fac44af49c5324d4857665a38f696fe47a0c15fbca5b458279e1c4a32c39e" + }, + "Std.Time.Zoned.ZoneRules": { + "relative_path": "lib/lean/Std/Time/Zoned/ZoneRules.olean", + "sha256": "86b9ebb4ce064c7f5c68fe3933a99d30e53d74c0a967669b7f23baffe77a4f1a" + }, + "Std.Time.Zoned.ZonedDateTime": { + "relative_path": "lib/lean/Std/Time/Zoned/ZonedDateTime.olean", + "sha256": "22285b4d4b6851745f3ba5b2fb79d739eb3000deebcc2ccdfbedec637ee53cd8" + } +} From 574c9eca0073c7517f4c1380a6588a2a5c9112f7 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:33:24 +1030 Subject: [PATCH 08/22] formal(mat009): bind Lean receipts and define isolated mutations --- .../lean/attempts/002/EVIDENCE_MANIFEST.json | 30 +++ formal/sonification/mat009/lean/negative.py | 171 +++++++++++++++++ formal/sonification/mat009/lean/verify.py | 176 ++++++++++++++++++ ...onification_formal_mat009_lean_receipts.py | 87 +++++++++ 4 files changed, 464 insertions(+) create mode 100644 formal/sonification/mat009/lean/attempts/002/EVIDENCE_MANIFEST.json create mode 100644 formal/sonification/mat009/lean/negative.py create mode 100644 formal/sonification/mat009/lean/verify.py create mode 100644 tests/test_sonification_formal_mat009_lean_receipts.py diff --git a/formal/sonification/mat009/lean/attempts/002/EVIDENCE_MANIFEST.json b/formal/sonification/mat009/lean/attempts/002/EVIDENCE_MANIFEST.json new file mode 100644 index 0000000..6dec709 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/002/EVIDENCE_MANIFEST.json @@ -0,0 +1,30 @@ +{ + "files_sha256": { + "build-00-SplitModel.json": "34ce5cf3d1dc2c4f740ea0360be7eaeec34e619315b63cec306d04e58076115c", + "build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.json": "5fccb56c651f29766987206416ba9d02ea3b95b4bd43f0ee67d1d8a0854203fd", + "build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.json": "d55c0693f763865b7ebc254fbd86ec266e650e93e146cea17407b465ecded54e", + "build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "build-03-ExactTypes.json": "71ff2627b1b9224d97347d827e310a1c73d5f2ab9fa3113ec1e03ecb4e870780", + "build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.json": "50a6752ba2f65a5cea9a1cb436cef3fdda1b5ea8122cd9a15dd255e7b85cc392", + "build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.stdout": "21d9dcb639ded4b2c3047045038ff0d3a3c216f2c1f57554d0832fb81e7042cc", + "declarations.json": "b3b5211e5edbbf49ac083f520bede6fef89ac3faccfa93b1d563e710f5f2537f", + "lean-version.json": "891fd7e9d7ca7393779b1eafec93925d0eb39390da8bb66ed47d2d72a5bd8d5b", + "lean-version.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "lean-version.stdout": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b", + "named-axioms.json": "d726df048cf1d5d7528afe2838eaa8a05b31b6a10c3b2a34109380b4bf779b1f", + "result.json": "74ed460c20a7ddc98d53891fc3a34de63404169f40405fe08fbcac2e4b6d85b1", + "theorem-types.json": "8ebc9839c12845f0410085754b475d7dd0ebf6c218869eebe39f2484104ddf5b", + "toolchain-imports.json": "69c9e85cad9c3ec024130bd80dc3e1fa6351053f135304268741bf1f0fd1b2ad" + }, + "proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "schema": "sonification-mat009-lean-evidence-v1", + "scope": "checked eligible-row mathematical models; CPython refinement OPEN" +} diff --git a/formal/sonification/mat009/lean/negative.py b/formal/sonification/mat009/lean/negative.py new file mode 100644 index 0000000..beac13e --- /dev/null +++ b/formal/sonification/mat009/lean/negative.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python3 +"""Run isolated MAT009 theorem and trust mutations, retaining original logs.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import os +import subprocess +import sys +import tempfile +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] +BASELINE = "a09aab6572fb9c3875d5f2940bdb17ec55c358d5" +MODULES = ("SplitModel", "DiagnosticFirstOwner", "TypedConsumer", "ExactTypes", "LeanAudit") + + +def sha(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def replace_once(source: str, before: str, after: str) -> str: + if source.count(before) != 1: + raise ValueError(f"mutation anchor is not unique: {before[:60]!r}") + return source.replace(before, after, 1) + + +def variants() -> dict[str, tuple[str, str, str, str]]: + split = (HERE / "SplitModel.lean").read_text() + diagnostic = (HERE / "DiagnosticFirstOwner.lean").read_text() + weak_start = split.index("theorem M009_R6_final_leakage_iff") + weak_end = split.index("\ndef noParent", weak_start) + weak = (split[:weak_start] + + "theorem M009_R6_final_leakage_iff : True := by trivial\n" + + split[weak_end:]) + return { + "drop_cross_conflict_stickiness": ( + "SplitModel", + replace_once(split, "crossed := s.crossed \u2228\n ∃ previous : Role,", + "crossed :=\n ∃ previous : Role,"), + "SplitModel", "unsolved goals", + ), + "drop_historical_campaign_membership": ( + "SplitModel", + replace_once(split, + "s.campaigns role key \u2228 (role = row.role ∧ key = row.campaign)", + "(role = row.role ∧ key = row.campaign)"), + "SplitModel", "unsolved goals", + ), + "weaken_final_leakage_theorem": ( + "SplitModel", weak, "TypedConsumer", "M009_R6_final_leakage_iff", + ), + "change_diagnostic_first_owner_update": ( + "DiagnosticFirstOwner", + replace_once(diagnostic, "| some first => some first", + "| some first => some candidate"), + "DiagnosticFirstOwner", "unsolved goals", + ), + "prohibited_project_axiom": ( + "SplitModel", + replace_once(split, "\nend MAT009\n", + "\naxiom fabricated_physical_admission : False\n\nend MAT009\n"), + "LeanAudit", "project axiom declaration", + ), + "prohibited_sorry": ( + "SplitModel", + replace_once(split, "\nend MAT009\n", + "\ndef hidden_unproved : Nat := by sorry\n\nend MAT009\n"), + "SplitModel", "sorry", + ), + } + + +def run_case( + out: Path, name: str, mutation: tuple[str, str, str, str], lean: Path, +) -> dict: + target, mutant, expected_module, expected_text = mutation + case = out / name + case.mkdir() + (case / "mutant-source.lean.txt").write_text(mutant) + commands = [] + with tempfile.TemporaryDirectory(prefix=f"mat009-{name}-") as temp: + work = Path(temp) + for module in MODULES: + raw = (HERE / f"{module}.lean").read_text() + (work / f"{module}.lean").write_text(mutant if module == target else raw) + env = {**os.environ, "LEAN_PATH": str(work)} + for index, module in enumerate(MODULES): + argv = [str(lean), "--error=warning", "-o", + str(work / f"{module}.olean"), f"{module}.lean"] + timed_out = False + try: + result = subprocess.run(argv, cwd=work, env=env, + capture_output=True, timeout=180) + code, stdout, stderr = result.returncode, result.stdout, result.stderr + except subprocess.TimeoutExpired as exc: + timed_out = True + code, stdout, stderr = None, exc.stdout or b"", exc.stderr or b"" + label = f"build-{index:02d}-{module}" + (case / f"{label}.stdout").write_bytes(stdout) + (case / f"{label}.stderr").write_bytes(stderr) + commands.append({ + "argv": argv, "exit_code": code, "timed_out": timed_out, + "stdout_sha256": sha(stdout), "stderr_sha256": sha(stderr), + }) + if code != 0 or timed_out: + diagnostic = (stdout + stderr).decode("utf-8", errors="replace") + detected = (module == expected_module and not timed_out and + expected_text in diagnostic) + break + else: + module, diagnostic, detected = "NONE", "no failure", False + row = { + "mutation": name, + "target_module": target, + "mutant_sha256": sha(mutant.encode()), + "expected_failure_module": expected_module, + "observed_failure_module": module, + "expected_diagnostic_text": expected_text, + "detected": detected, + "commands": commands, + } + (case / "result.json").write_text(json.dumps(row, indent=2, sort_keys=True) + "\n") + return row + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--lean", required=True, type=Path) + parser.add_argument("--out", required=True, type=Path) + args = parser.parse_args() + out = args.out.resolve() + out.mkdir(parents=True, exist_ok=False) + lean = args.lean.resolve(strict=True) + nominal = json.loads((HERE / "attempts/002/result.json").read_text()) + if sha(lean.read_bytes()) != nominal["lean_executable_sha256"]: + raise ValueError("negative controls require the nominal Lean executable") + for module in MODULES: + path = f"formal/sonification/mat009/lean/{module}.lean" + historical = subprocess.check_output(["git", "show", f"{BASELINE}:{path}"], cwd=ROOT) + if historical != (HERE / f"{module}.lean").read_bytes(): + raise ValueError(f"proof source drift before mutation: {module}") + results = [run_case(out, name, mutation, lean) + for name, mutation in variants().items()] + status = "PASS" if all(row["detected"] for row in results) else "FAIL" + report = { + "status": status, + "proof_input_commit": BASELINE, + "negative_runner_sha256": sha(Path(__file__).read_bytes()), + "negative_runner_commit": subprocess.check_output( + ["git", "rev-parse", "HEAD"], cwd=ROOT, text=True + ).strip(), + "lean_executable_sha256": sha(lean.read_bytes()), + "scope": "negative controls for mathematical proof and trust checker only", + "REFINEMENT_PROVED": "OPEN", + "cases": [{"mutation": row["mutation"], "detected": row["detected"], + "expected_failure_module": row["expected_failure_module"], + "observed_failure_module": row["observed_failure_module"]} + for row in results], + } + (out / "result.json").write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + print(json.dumps({"status": status, "detected": sum(r["detected"] for r in results), + "total": len(results), "out": str(out)}, sort_keys=True)) + return 0 if status == "PASS" else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/formal/sonification/mat009/lean/verify.py b/formal/sonification/mat009/lean/verify.py new file mode 100644 index 0000000..8e44517 --- /dev/null +++ b/formal/sonification/mat009/lean/verify.py @@ -0,0 +1,176 @@ +#!/usr/bin/env python3 +"""Verify retained MAT009 Lean receipts against pinned proof inputs and toolchain. + +This verifies archived execution integrity. Independent proof acceptance still +requires review of the intended statements and trust model. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import re +import subprocess +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[3] +DEFAULT_ATTEMPT = HERE / "attempts/002" +BASELINE = "a09aab6572fb9c3875d5f2940bdb17ec55c358d5" +MANIFEST_SHA256 = "c068cb09fa08737a25bf49c17fa7cbca1e31dbbaa5ab388532b5529e1e41c817" +MODULES = ( + "SplitModel", "DiagnosticFirstOwner", "TypedConsumer", "ExactTypes", + "LeanAudit", +) +INPUTS = {*(f"{m}.lean" for m in MODULES), "PROOF_NOTES.md", "lean-toolchain", "check.py"} +ALLOWED_AXIOMS = {"propext", "Quot.sound", "Classical.choice"} +VERSION = "Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release)" +AXIOM_LINE = re.compile( + r"^'([^']+)' (?:depends on axioms: \[([^]]*)\]|does not depend on any axioms)$" +) + + +def sha(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def require(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def verify(attempt: Path = DEFAULT_ATTEMPT, lean: Path | None = None) -> dict: + require(attempt.is_dir() and not attempt.is_symlink(), "missing ordinary attempt directory") + manifest_path = attempt / "EVIDENCE_MANIFEST.json" + require(manifest_path.is_file() and not manifest_path.is_symlink(), "missing evidence manifest") + raw = manifest_path.read_bytes() + require(sha(raw) == MANIFEST_SHA256, "evidence manifest changed") + manifest = json.loads(raw) + require(manifest["schema"] == "sonification-mat009-lean-evidence-v1", "manifest schema changed") + require(manifest["proof_input_commit"] == BASELINE, "proof input commit changed") + files = manifest["files_sha256"] + require(len(files) == 23, "retained evidence file count changed") + require({p.name for p in attempt.iterdir()} == set(files) | {manifest_path.name}, + "retained evidence file inventory changed") + for name, digest in files.items(): + path = attempt / name + require(path.is_file() and not path.is_symlink(), f"missing ordinary evidence file: {name}") + require(sha(path.read_bytes()) == digest, f"altered evidence file: {name}") + + result = json.loads((attempt / "result.json").read_text()) + require(result["status"] == "PASS" and result["MODEL_PROVED"] == + "PASS_FOR_SCOPED_MATHEMATICAL_MODEL", "proof execution did not pass") + require(result["REFINEMENT_PROVED"] == "OPEN" and + result["AUDIT_ACCEPTED"] == "OPEN", "receipt overstates assurance") + require(result["baseline_commit"] == BASELINE, "result proof baseline changed") + require(set(result["input_sha256"]) == INPUTS, "proof input inventory changed") + require(result["declaration_count"] == 351 and + result["theorem_declaration_count_including_generated"] == 95 and + len(result["named_intended_theorems"]) == 22, + "proof declaration count changed") + actual_modules = {p.name for p in HERE.rglob("*.lean")} + require(actual_modules == {f"{module}.lean" for module in MODULES}, + "current proof module coverage changed") + for name, digest in result["input_sha256"].items(): + current = HERE / name + require(current.is_file() and not current.is_symlink() and + sha(current.read_bytes()) == digest, f"stale proof source: {name}") + original = subprocess.check_output( + ["git", "show", f"{BASELINE}:formal/sonification/mat009/lean/{name}"], + cwd=ROOT, + ) + require(sha(original) == digest, f"proof commit input mismatch: {name}") + if lean is None: + lean = Path.home() / ".elan/toolchains/leanprover--lean4---v4.19.0/bin/lean" + lean = lean.resolve(strict=True) + require(sha(lean.read_bytes()) == result["lean_executable_sha256"], + "installed Lean executable changed") + local_version = subprocess.run([str(lean), "--version"], capture_output=True, check=True) + require(local_version.stdout.decode().strip() == VERSION and + result["lean_version"] == VERSION, "installed Lean version changed") + + for label in ("lean-version", *(f"build-{i:02d}-{m}" for i, m in enumerate(MODULES))): + receipt = json.loads((attempt / f"{label}.json").read_text()) + require(receipt["exit_code"] == 0 and receipt["timed_out"] is False, + f"failed or timed-out Lean job: {label}") + argv = receipt["argv"] + require(Path(argv[0]).name == "lean", f"unexpected prover executable: {label}") + if label == "lean-version": + require(argv[1:] == ["--version"], "version command changed") + else: + module = label.split("-", 2)[2] + require(argv[1:3] == ["--error=warning", "-o"] and + argv[-1] == f"{module}.lean" and + Path(argv[-2]).name == f"{module}.olean" and + receipt["cwd"].endswith("formal/sonification/mat009/lean"), + f"Lean build command changed: {label}") + for stream in ("stdout", "stderr"): + require(sha((attempt / f"{label}.{stream}").read_bytes()) == + receipt[f"{stream}_sha256"], f"altered {label} {stream}") + + audit_lines = (attempt / "build-04-LeanAudit.stdout").read_text().splitlines() + modules = {line.removeprefix("MAT009_MODULE ") for line in audit_lines + if line.startswith("MAT009_MODULE ")} + require(modules == set(MODULES), "retained audit module coverage changed") + summaries = [line for line in audit_lines if line.startswith("MAT009_AUDIT ")] + require(summaries == ["MAT009_AUDIT declarations=351 theorems=95"], + "retained audit summary changed") + declarations = [json.loads(line.removeprefix("MAT009_DECL ")) for line in audit_lines + if line.startswith("MAT009_DECL ")] + require(declarations == json.loads((attempt / "declarations.json").read_text()) and + len(declarations) == 351, "retained declaration inventory changed") + names = [row["declaration"] for row in declarations] + require(len(set(names)) == len(names), "duplicate declaration in retained audit") + named = {row["declaration"]: row["type"] for row in declarations + if row["declaration"] in result["named_intended_theorems"]} + require(named == json.loads((attempt / "theorem-types.json").read_text()) and + set(named) == set(result["named_intended_theorems"]), + "retained theorem statements changed") + for row in declarations: + require(row["origin"] in MODULES, "declaration from unexpected module") + if row["kind"] != "compiler_auxiliary": + require(not row["is_axiom"] and not row["unsafe_definition"] and + set(row["axioms"]) <= ALLOWED_AXIOMS, + f"unapproved logical assumption: {row['declaration']}") + + printed = {} + for line in (attempt / "build-02-TypedConsumer.stdout").read_text().splitlines(): + match = AXIOM_LINE.match(line) + if match: + printed[match[1]] = ( + sorted(a.strip() for a in match[2].split(",")) if match[2] else [] + ) + require(printed == json.loads((attempt / "named-axioms.json").read_text()) and + len(printed) == 18 and all(set(v) <= ALLOWED_AXIOMS for v in printed.values()), + "named theorem transitive axioms changed") + + imports = {line.removeprefix("MAT009_IMPORT ") for line in audit_lines + if line.startswith("MAT009_IMPORT ")} + external = json.loads((attempt / "toolchain-imports.json").read_text()) + require(set(external) == imports - set(MODULES) and len(external) == 1303, + "toolchain import closure changed") + root = lean.parent.parent + for module, identity in external.items(): + relative = Path("lib/lean") / (module.replace(".", "/") + ".olean") + require(identity["relative_path"] == str(relative), + f"toolchain relative import changed: {module}") + path = root / relative + require(path.is_file() and not path.is_symlink() and + sha(path.read_bytes()) == identity["sha256"], + f"installed toolchain import changed: {module}") + return { + "status": "MAT009_LEAN_EVIDENCE_BOUND", + "named_model_theorems": len(named), + "toolchain_imports": len(external), + "REFINEMENT_PROVED": "OPEN", + "AUDIT_ACCEPTED": "OPEN", + } + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--attempt", type=Path, default=DEFAULT_ATTEMPT) + parser.add_argument("--lean", type=Path) + args = parser.parse_args() + print(json.dumps(verify(args.attempt, args.lean), sort_keys=True)) diff --git a/tests/test_sonification_formal_mat009_lean_receipts.py b/tests/test_sonification_formal_mat009_lean_receipts.py new file mode 100644 index 0000000..c1480bb --- /dev/null +++ b/tests/test_sonification_formal_mat009_lean_receipts.py @@ -0,0 +1,87 @@ +"""Fail-closed controls for the retained MAT009 Lean proof receipt.""" + +from __future__ import annotations + +import shutil +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch + +from formal.sonification.mat009.lean import verify as lean_verify + + +class Mat009LeanReceiptTests(unittest.TestCase): + def setUp(self) -> None: + self.temp = tempfile.TemporaryDirectory(prefix="mat009-lean-receipt-control-") + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + self.attempt = self.root / "attempt" + shutil.copytree(lean_verify.DEFAULT_ATTEMPT, self.attempt) + + def proof_copy(self) -> Path: + proof = self.root / "proof" + proof.mkdir() + for name in lean_verify.INPUTS: + shutil.copyfile(lean_verify.HERE / name, proof / name) + return proof + + def test_intact_receipt(self) -> None: + result = lean_verify.verify(self.attempt) + self.assertEqual(result["status"], "MAT009_LEAN_EVIDENCE_BOUND") + self.assertEqual(result["REFINEMENT_PROVED"], "OPEN") + + def test_removed_build_log(self) -> None: + (self.attempt / "build-04-LeanAudit.stdout").unlink() + with self.assertRaisesRegex(ValueError, "evidence file inventory changed"): + lean_verify.verify(self.attempt) + + def test_altered_build_stderr(self) -> None: + (self.attempt / "build-03-ExactTypes.stderr").write_text("invented success\n") + with self.assertRaisesRegex(ValueError, "altered evidence file"): + lean_verify.verify(self.attempt) + + def test_removed_toolchain_import_receipt(self) -> None: + (self.attempt / "toolchain-imports.json").unlink() + with self.assertRaisesRegex(ValueError, "evidence file inventory changed"): + lean_verify.verify(self.attempt) + + def test_altered_model_assurance(self) -> None: + result = self.attempt / "result.json" + result.write_text(result.read_text().replace('"REFINEMENT_PROVED": "OPEN"', + '"REFINEMENT_PROVED": "PASS"')) + with self.assertRaisesRegex(ValueError, "altered evidence file"): + lean_verify.verify(self.attempt) + + def test_altered_theorem_type_inventory(self) -> None: + types = self.attempt / "theorem-types.json" + types.write_text(types.read_text().replace("MAT009.M009_R1_initial", "False")) + with self.assertRaisesRegex(ValueError, "altered evidence file"): + lean_verify.verify(self.attempt) + + def test_stale_proof_source(self) -> None: + proof = self.proof_copy() + source = proof / "SplitModel.lean" + source.write_text(source.read_text() + "\n-- unexpected source edit\n") + with ( + patch.object(lean_verify, "HERE", proof), + self.assertRaisesRegex(ValueError, "stale proof source"), + ): + lean_verify.verify(self.attempt) + + def test_unimported_failing_module(self) -> None: + proof = self.proof_copy() + (proof / "Unimported.lean").write_text("theorem hidden_false : False := by trivial\n") + with ( + patch.object(lean_verify, "HERE", proof), + self.assertRaisesRegex(ValueError, "proof module coverage changed"), + ): + lean_verify.verify(self.attempt) + + def test_wrong_toolchain_binary(self) -> None: + with self.assertRaisesRegex(ValueError, "installed Lean executable changed"): + lean_verify.verify(self.attempt, Path("/bin/true")) + + +if __name__ == "__main__": + unittest.main() From 496c90c97ef0e5e0294dee706a842a888a3c47ea Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:34:07 +1030 Subject: [PATCH 09/22] formal(mat009): retain mutation-runner anchor failure and repair case --- formal/sonification/mat009/lean/negative.py | 4 +++- .../mat009/lean/negative/001/result.json | 17 +++++++++++++++++ .../mat009/lean/negative/001/runner.stderr | 17 +++++++++++++++++ .../mat009/lean/negative/001/runner.stdout | 0 4 files changed, 37 insertions(+), 1 deletion(-) create mode 100644 formal/sonification/mat009/lean/negative/001/result.json create mode 100644 formal/sonification/mat009/lean/negative/001/runner.stderr create mode 100644 formal/sonification/mat009/lean/negative/001/runner.stdout diff --git a/formal/sonification/mat009/lean/negative.py b/formal/sonification/mat009/lean/negative.py index beac13e..212b8bd 100644 --- a/formal/sonification/mat009/lean/negative.py +++ b/formal/sonification/mat009/lean/negative.py @@ -46,7 +46,9 @@ def variants() -> dict[str, tuple[str, str, str, str]]: "drop_historical_campaign_membership": ( "SplitModel", replace_once(split, - "s.campaigns role key \u2228 (role = row.role ∧ key = row.campaign)", + "campaigns := fun role key =>\n s.campaigns role key \u2228 " + "(role = row.role ∧ key = row.campaign)", + "campaigns := fun role key =>\n " "(role = row.role ∧ key = row.campaign)"), "SplitModel", "unsolved goals", ), diff --git a/formal/sonification/mat009/lean/negative/001/result.json b/formal/sonification/mat009/lean/negative/001/result.json new file mode 100644 index 0000000..c2d8d2e --- /dev/null +++ b/formal/sonification/mat009/lean/negative/001/result.json @@ -0,0 +1,17 @@ +{ + "argv": [ + "python3", + "formal/sonification/mat009/lean/negative.py", + "--lean", + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--out", + "formal/sonification/mat009/lean/negative/001/reproduction" + ], + "cause": "non-unique campaign mutation anchor; no mutation cases executed", + "exit_code": 1, + "script_commit": "574c9ec", + "script_sha256": "5c2894a70267b2eff82241b0aa2cf6e36079ecac451edc401eee9736368ebe2b", + "status": "FAILED_DEVELOPMENT_ATTEMPT", + "stderr_sha256": "405a13f88a20584865d5e7aba8059024eb0af7580e0f788a8c55cb3cda3cf466", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" +} diff --git a/formal/sonification/mat009/lean/negative/001/runner.stderr b/formal/sonification/mat009/lean/negative/001/runner.stderr new file mode 100644 index 0000000..5281259 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/001/runner.stderr @@ -0,0 +1,17 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 171, in + sys.exit(main()) + ~~~~^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 147, in main + for name, mutation in variants().items()] + ~~~~~~~~^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 48, in variants + replace_once(split, + ~~~~~~~~~~~~^^^^^^^ + "s.campaigns role key \u2228 (role = row.role ∧ key = row.campaign)", + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + "(role = row.role ∧ key = row.campaign)"), + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 27, in replace_once + raise ValueError(f"mutation anchor is not unique: {before[:60]!r}") +ValueError: mutation anchor is not unique: 's.campaigns role key ∨ (role = row.role ∧ key = row.campaign' diff --git a/formal/sonification/mat009/lean/negative/001/runner.stdout b/formal/sonification/mat009/lean/negative/001/runner.stdout new file mode 100644 index 0000000..e69de29 From 5620029fb724ac41827a0c41c4c677b9594464f3 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:35:24 +1030 Subject: [PATCH 10/22] formal(mat009): retain mutation diagnostics and correct expected failures --- formal/sonification/mat009/lean/negative.py | 4 +- .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 17 + .../mutant-source.lean.txt | 78 + .../result.json | 37 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 29 + .../mutant-source.lean.txt | 379 +++++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 42 + .../mutant-source.lean.txt | 379 +++++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1493 ++++++++++++++++ .../mutant-source.lean.txt | 381 +++++ .../002/prohibited_project_axiom/result.json | 76 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 1 + .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1500 +++++++++++++++++ .../prohibited_sorry/mutant-source.lean.txt | 381 +++++ .../negative/002/prohibited_sorry/result.json | 76 + .../mat009/lean/negative/002/result.json | 47 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 68 + .../mutant-source.lean.txt | 369 ++++ .../weaken_final_leakage_theorem/result.json | 50 + 48 files changed, 5595 insertions(+), 2 deletions(-) create mode 100644 formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/result.json create mode 100644 formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/result.json create mode 100644 formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/result.json create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/result.json create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/002/prohibited_sorry/result.json create mode 100644 formal/sonification/mat009/lean/negative/002/result.json create mode 100644 formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/result.json diff --git a/formal/sonification/mat009/lean/negative.py b/formal/sonification/mat009/lean/negative.py index 212b8bd..2e03b45 100644 --- a/formal/sonification/mat009/lean/negative.py +++ b/formal/sonification/mat009/lean/negative.py @@ -41,7 +41,7 @@ def variants() -> dict[str, tuple[str, str, str, str]]: "SplitModel", replace_once(split, "crossed := s.crossed \u2228\n ∃ previous : Role,", "crossed :=\n ∃ previous : Role,"), - "SplitModel", "unsolved goals", + "SplitModel", "application type mismatch", ), "drop_historical_campaign_membership": ( "SplitModel", @@ -71,7 +71,7 @@ def variants() -> dict[str, tuple[str, str, str, str]]: "SplitModel", replace_once(split, "\nend MAT009\n", "\ndef hidden_unproved : Nat := by sorry\n\nend MAT009\n"), - "SplitModel", "sorry", + "LeanAudit", "sorryAx", ), } diff --git a/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..338f088 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout @@ -0,0 +1,17 @@ +DiagnosticFirstOwner.lean:23:13: warning: unused variable `first` +note: this linter can be disabled with `set_option linter.unusedVariables false` +DiagnosticFirstOwner.lean:35:68: error: unsolved goals +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:55:2: error: unsolved goals +case pos +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:75:38: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/mutant-source.lean.txt new file mode 100644 index 0000000..7dd6c18 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/mutant-source.lean.txt @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some candidate + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/result.json b/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/result.json new file mode 100644 index 0000000..c006eca --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/change_diagnostic_first_owner_update/result.json @@ -0,0 +1,37 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-qzlh1__l/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-qzlh1__l/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "DiagnosticFirstOwner", + "mutant_sha256": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner", + "target_module": "DiagnosticFirstOwner" +} diff --git a/formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout new file mode 100644 index 0000000..7afbe9e --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout @@ -0,0 +1,29 @@ +SplitModel.lean:157:2: error: tactic 'rfl' failed, the left-hand side + (step s row).crossed +is not definitionally equal to the right-hand side + s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +s : State +row : Row +⊢ (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +SplitModel.lean:173:4: error: type mismatch + Or.inl h +has type + s.crossed ∨ ?m.4965 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:260:33: error: application type mismatch + ih (step s row) (Or.inl h) +argument + Or.inl h +has type + s.crossed ∨ ?m.5382 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:285:36: error: application type mismatch + scan_crossed_sticky (step (scan s before) row) after (Or.inr h) +argument + Or.inr h +has type + ?m.5421 ∨ ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role : Prop +but is expected to have type + (step (scan s before) row).crossed : Prop diff --git a/formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/mutant-source.lean.txt new file mode 100644 index 0000000..bf51182 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/result.json b/formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/result.json new file mode 100644 index 0000000..e668f74 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/drop_cross_conflict_stickiness/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_cross_conflict_stickiness-b7mgdi0g/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "timed_out": false + } + ], + "detected": false, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "SplitModel", + "mutant_sha256": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/build-00-SplitModel.stdout new file mode 100644 index 0000000..4bac996 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/build-00-SplitModel.stdout @@ -0,0 +1,42 @@ +SplitModel.lean:79:23: error: application type mismatch + And.intro (Or.inl htrain) +argument + Or.inl htrain +has type + s.campaigns Role.train key ∨ ?m.3876 : Prop +but is expected to have type + (step s row).campaigns Role.train key : Prop +SplitModel.lean:147:4: error: tactic 'rfl' failed, the left-hand side + (step s row).campaigns role key +is not definitionally equal to the right-hand side + s.campaigns role key ∨ role = row.role ∧ key = row.campaign +case refine_3 +s : State +row : Row +role : Role +key : String +⊢ (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign +SplitModel.lean:169:4: error: type mismatch + Or.inl h +has type + s.campaigns role campaign ∨ ?m.4953 : Prop +but is expected to have type + (step s row).campaigns role campaign : Prop +SplitModel.lean:222:21: error: unsolved goals +case cons +role : Role +key : String +row : Row +rest : List Row +ih : + ∀ (s : State), + (scan s rest).campaigns role key ↔ s.campaigns role key ∨ ∃ row, row ∈ rest ∧ row.role = role ∧ row.campaign = key +s : State +hhead : + (∃ r, r ∈ row :: rest ∧ r.role = role ∧ r.campaign = key) ↔ + row.role = role ∧ row.campaign = key ∨ ∃ r, r ∈ rest ∧ r.role = role ∧ r.campaign = key +⊢ (role = row.role ∧ key = row.campaign ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign) ↔ + role = row.role ∧ key = row.campaign ∨ + s.campaigns role key ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign +SplitModel.lean:368:35: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/mutant-source.lean.txt new file mode 100644 index 0000000..abf1e5e --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/result.json b/formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/result.json new file mode 100644 index 0000000..ef8a788 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/drop_historical_campaign_membership/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_historical_campaign_membership-797k1qgn/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "SplitModel", + "mutant_sha256": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-03-ExactTypes.stderr b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-03-ExactTypes.stdout b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-04-LeanAudit.stderr b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-04-LeanAudit.stdout b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-04-LeanAudit.stdout new file mode 100644 index 0000000..1e4568e --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/build-04-LeanAudit.stdout @@ -0,0 +1,1493 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: project axiom declaration MAT009.fabricated_physical_admission diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/mutant-source.lean.txt new file mode 100644 index 0000000..6fb45d8 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom fabricated_physical_admission : False + +end MAT009 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/result.json b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/result.json new file mode 100644 index 0000000..72ae8e3 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/prohibited_project_axiom/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "project axiom declaration", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-00-SplitModel.stdout new file mode 100644 index 0000000..a165e03 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-00-SplitModel.stdout @@ -0,0 +1 @@ +SplitModel.lean:379:4: warning: declaration uses 'sorry' diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-03-ExactTypes.stderr b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-03-ExactTypes.stdout b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-04-LeanAudit.stderr b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-04-LeanAudit.stdout b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-04-LeanAudit.stdout new file mode 100644 index 0000000..8baf730 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/build-04-LeanAudit.stdout @@ -0,0 +1,1500 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: unapproved transitive axiom sorryAx in MAT009.hidden_unproved (origin SplitModel) diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/mutant-source.lean.txt new file mode 100644 index 0000000..287973b --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +def hidden_unproved : Nat := by sorry + +end MAT009 diff --git a/formal/sonification/mat009/lean/negative/002/prohibited_sorry/result.json b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/result.json new file mode 100644 index 0000000..c24d4fb --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/prohibited_sorry/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "timed_out": false + } + ], + "detected": false, + "expected_diagnostic_text": "sorry", + "expected_failure_module": "SplitModel", + "mutant_sha256": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/negative/002/result.json b/formal/sonification/mat009/lean/negative/002/result.json new file mode 100644 index 0000000..6215fda --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/result.json @@ -0,0 +1,47 @@ +{ + "REFINEMENT_PROVED": "OPEN", + "cases": [ + { + "detected": false, + "expected_failure_module": "SplitModel", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "SplitModel", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "TypedConsumer", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer" + }, + { + "detected": true, + "expected_failure_module": "DiagnosticFirstOwner", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit" + }, + { + "detected": false, + "expected_failure_module": "SplitModel", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit" + } + ], + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "negative_runner_commit": "496c90c97ef0e5e0294dee706a842a888a3c47ea", + "negative_runner_sha256": "b06e5f54e157c61475661e5066321e65f3692b177e116f52c18f47337ce043c3", + "proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "scope": "negative controls for mathematical proof and trust checker only", + "status": "FAIL" +} diff --git a/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..85516a3 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout @@ -0,0 +1,68 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff : True +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +TypedConsumer.lean:43:9: error: function expected at + M009_R6_final_leakage_iff +term has type + True +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' does not depend on any axioms +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, sorryAx, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/mutant-source.lean.txt new file mode 100644 index 0000000..bd8b105 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/mutant-source.lean.txt @@ -0,0 +1,369 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff : True := by trivial + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/result.json b/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/result.json new file mode 100644 index 0000000..9882436 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/002/weaken_final_leakage_theorem/result.json @@ -0,0 +1,50 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-tdtq_18o/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-tdtq_18o/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-tdtq_18o/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "M009_R6_final_leakage_iff", + "expected_failure_module": "TypedConsumer", + "mutant_sha256": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer", + "target_module": "SplitModel" +} From b9a828695b56b9caf73acbee0a5c35c2e66b4bef Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:37:30 +1030 Subject: [PATCH 11/22] formal(mat009): retain six detected proof mutations and source drift control --- .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 17 + .../mutant-source.lean.txt | 78 + .../result.json | 37 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 29 + .../mutant-source.lean.txt | 379 +++++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 42 + .../mutant-source.lean.txt | 379 +++++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1493 ++++++++++++++++ .../mutant-source.lean.txt | 381 +++++ .../003/prohibited_project_axiom/result.json | 76 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 1 + .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1500 +++++++++++++++++ .../prohibited_sorry/mutant-source.lean.txt | 381 +++++ .../negative/003/prohibited_sorry/result.json | 76 + .../mat009/lean/negative/003/result.json | 47 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 68 + .../mutant-source.lean.txt | 369 ++++ .../weaken_final_leakage_theorem/result.json | 50 + .../lean/negative/ARCHIVE_MANIFEST.json | 109 ++ .../mat009/lean/verify_negative.py | 112 ++ ...ication_formal_mat009_negative_receipts.py | 43 + ...ification_formal_mat009_source_mutation.py | 45 + 51 files changed, 5902 insertions(+) create mode 100644 formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/result.json create mode 100644 formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/result.json create mode 100644 formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/result.json create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/result.json create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/003/prohibited_sorry/result.json create mode 100644 formal/sonification/mat009/lean/negative/003/result.json create mode 100644 formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/result.json create mode 100644 formal/sonification/mat009/lean/negative/ARCHIVE_MANIFEST.json create mode 100644 formal/sonification/mat009/lean/verify_negative.py create mode 100644 tests/test_sonification_formal_mat009_negative_receipts.py create mode 100644 tests/test_sonification_formal_mat009_source_mutation.py diff --git a/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..338f088 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout @@ -0,0 +1,17 @@ +DiagnosticFirstOwner.lean:23:13: warning: unused variable `first` +note: this linter can be disabled with `set_option linter.unusedVariables false` +DiagnosticFirstOwner.lean:35:68: error: unsolved goals +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:55:2: error: unsolved goals +case pos +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:75:38: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/mutant-source.lean.txt new file mode 100644 index 0000000..7dd6c18 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/mutant-source.lean.txt @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some candidate + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/result.json b/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/result.json new file mode 100644 index 0000000..fb1e6cb --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/change_diagnostic_first_owner_update/result.json @@ -0,0 +1,37 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-5g641ca4/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-5g641ca4/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "DiagnosticFirstOwner", + "mutant_sha256": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner", + "target_module": "DiagnosticFirstOwner" +} diff --git a/formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout new file mode 100644 index 0000000..7afbe9e --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout @@ -0,0 +1,29 @@ +SplitModel.lean:157:2: error: tactic 'rfl' failed, the left-hand side + (step s row).crossed +is not definitionally equal to the right-hand side + s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +s : State +row : Row +⊢ (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +SplitModel.lean:173:4: error: type mismatch + Or.inl h +has type + s.crossed ∨ ?m.4965 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:260:33: error: application type mismatch + ih (step s row) (Or.inl h) +argument + Or.inl h +has type + s.crossed ∨ ?m.5382 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:285:36: error: application type mismatch + scan_crossed_sticky (step (scan s before) row) after (Or.inr h) +argument + Or.inr h +has type + ?m.5421 ∨ ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role : Prop +but is expected to have type + (step (scan s before) row).crossed : Prop diff --git a/formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/mutant-source.lean.txt new file mode 100644 index 0000000..bf51182 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/result.json b/formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/result.json new file mode 100644 index 0000000..4cf3c03 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/drop_cross_conflict_stickiness/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_cross_conflict_stickiness-mplmly4j/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "application type mismatch", + "expected_failure_module": "SplitModel", + "mutant_sha256": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/build-00-SplitModel.stdout new file mode 100644 index 0000000..4bac996 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/build-00-SplitModel.stdout @@ -0,0 +1,42 @@ +SplitModel.lean:79:23: error: application type mismatch + And.intro (Or.inl htrain) +argument + Or.inl htrain +has type + s.campaigns Role.train key ∨ ?m.3876 : Prop +but is expected to have type + (step s row).campaigns Role.train key : Prop +SplitModel.lean:147:4: error: tactic 'rfl' failed, the left-hand side + (step s row).campaigns role key +is not definitionally equal to the right-hand side + s.campaigns role key ∨ role = row.role ∧ key = row.campaign +case refine_3 +s : State +row : Row +role : Role +key : String +⊢ (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign +SplitModel.lean:169:4: error: type mismatch + Or.inl h +has type + s.campaigns role campaign ∨ ?m.4953 : Prop +but is expected to have type + (step s row).campaigns role campaign : Prop +SplitModel.lean:222:21: error: unsolved goals +case cons +role : Role +key : String +row : Row +rest : List Row +ih : + ∀ (s : State), + (scan s rest).campaigns role key ↔ s.campaigns role key ∨ ∃ row, row ∈ rest ∧ row.role = role ∧ row.campaign = key +s : State +hhead : + (∃ r, r ∈ row :: rest ∧ r.role = role ∧ r.campaign = key) ↔ + row.role = role ∧ row.campaign = key ∨ ∃ r, r ∈ rest ∧ r.role = role ∧ r.campaign = key +⊢ (role = row.role ∧ key = row.campaign ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign) ↔ + role = row.role ∧ key = row.campaign ∨ + s.campaigns role key ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign +SplitModel.lean:368:35: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/mutant-source.lean.txt new file mode 100644 index 0000000..abf1e5e --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/result.json b/formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/result.json new file mode 100644 index 0000000..60e4592 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/drop_historical_campaign_membership/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_historical_campaign_membership-4ipi38ta/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "SplitModel", + "mutant_sha256": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-03-ExactTypes.stderr b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-03-ExactTypes.stdout b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-04-LeanAudit.stderr b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-04-LeanAudit.stdout b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-04-LeanAudit.stdout new file mode 100644 index 0000000..1e4568e --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/build-04-LeanAudit.stdout @@ -0,0 +1,1493 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: project axiom declaration MAT009.fabricated_physical_admission diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/mutant-source.lean.txt new file mode 100644 index 0000000..6fb45d8 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom fabricated_physical_admission : False + +end MAT009 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/result.json b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/result.json new file mode 100644 index 0000000..a53a3d7 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/prohibited_project_axiom/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "project axiom declaration", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-00-SplitModel.stdout new file mode 100644 index 0000000..a165e03 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-00-SplitModel.stdout @@ -0,0 +1 @@ +SplitModel.lean:379:4: warning: declaration uses 'sorry' diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-03-ExactTypes.stderr b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-03-ExactTypes.stdout b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-04-LeanAudit.stderr b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-04-LeanAudit.stdout b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-04-LeanAudit.stdout new file mode 100644 index 0000000..8baf730 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/build-04-LeanAudit.stdout @@ -0,0 +1,1500 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: unapproved transitive axiom sorryAx in MAT009.hidden_unproved (origin SplitModel) diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/mutant-source.lean.txt new file mode 100644 index 0000000..287973b --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +def hidden_unproved : Nat := by sorry + +end MAT009 diff --git a/formal/sonification/mat009/lean/negative/003/prohibited_sorry/result.json b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/result.json new file mode 100644 index 0000000..4fcaa6e --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/prohibited_sorry/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "sorryAx", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/negative/003/result.json b/formal/sonification/mat009/lean/negative/003/result.json new file mode 100644 index 0000000..7831e91 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/result.json @@ -0,0 +1,47 @@ +{ + "REFINEMENT_PROVED": "OPEN", + "cases": [ + { + "detected": true, + "expected_failure_module": "SplitModel", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "SplitModel", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "TypedConsumer", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer" + }, + { + "detected": true, + "expected_failure_module": "DiagnosticFirstOwner", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit" + } + ], + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "negative_runner_commit": "5620029fb724ac41827a0c41c4c677b9594464f3", + "negative_runner_sha256": "874ca7ff059394e97cc908d921dec51bbc0ff852c354baf1c8da7a7d557a352c", + "proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "scope": "negative controls for mathematical proof and trust checker only", + "status": "PASS" +} diff --git a/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..85516a3 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout @@ -0,0 +1,68 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff : True +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +TypedConsumer.lean:43:9: error: function expected at + M009_R6_final_leakage_iff +term has type + True +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' does not depend on any axioms +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, sorryAx, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/mutant-source.lean.txt b/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/mutant-source.lean.txt new file mode 100644 index 0000000..bd8b105 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/mutant-source.lean.txt @@ -0,0 +1,369 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff : True := by trivial + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/result.json b/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/result.json new file mode 100644 index 0000000..b9c7631 --- /dev/null +++ b/formal/sonification/mat009/lean/negative/003/weaken_final_leakage_theorem/result.json @@ -0,0 +1,50 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-ndmeeadq/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-ndmeeadq/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-ndmeeadq/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "M009_R6_final_leakage_iff", + "expected_failure_module": "TypedConsumer", + "mutant_sha256": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/negative/ARCHIVE_MANIFEST.json b/formal/sonification/mat009/lean/negative/ARCHIVE_MANIFEST.json new file mode 100644 index 0000000..6f64e7a --- /dev/null +++ b/formal/sonification/mat009/lean/negative/ARCHIVE_MANIFEST.json @@ -0,0 +1,109 @@ +{ + "accepted_attempt": "003", + "accepted_case_count": 6, + "files_sha256": { + "001/result.json": "092c87de243607f5721b9c55113b4223a2d3301e2c8c8acab82309c1afd24aeb", + "001/runner.stderr": "405a13f88a20584865d5e7aba8059024eb0af7580e0f788a8c55cb3cda3cf466", + "001/runner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "002/change_diagnostic_first_owner_update/mutant-source.lean.txt": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "002/change_diagnostic_first_owner_update/result.json": "759e5e2ec2b13fd4565d8419417628beb3a829357f53aa01ea18654ebef5c061", + "002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "002/drop_cross_conflict_stickiness/mutant-source.lean.txt": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "002/drop_cross_conflict_stickiness/result.json": "ccce8d856ccf63fa7bef4808bed50b06c7b68617e91351da87e617a555f08dc7", + "002/drop_historical_campaign_membership/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/drop_historical_campaign_membership/build-00-SplitModel.stdout": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "002/drop_historical_campaign_membership/mutant-source.lean.txt": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "002/drop_historical_campaign_membership/result.json": "9cfe5f060dde968cf7677f36bf0fc7305ac4bc8085bb75f4fd751c0106d558dc", + "002/prohibited_project_axiom/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "002/prohibited_project_axiom/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-04-LeanAudit.stdout": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "002/prohibited_project_axiom/mutant-source.lean.txt": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "002/prohibited_project_axiom/result.json": "ae8389c3439aaf40f6df4dde82ca0c9bf2c5ac21077f0cbf7ebee9620c6ed20b", + "002/prohibited_sorry/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-00-SplitModel.stdout": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "002/prohibited_sorry/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-04-LeanAudit.stdout": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "002/prohibited_sorry/mutant-source.lean.txt": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "002/prohibited_sorry/result.json": "863e887d061ebe06d802c76738510272c0d8b0521ca80a28728503f01db0e7cd", + "002/result.json": "7e72d51436d9d6c2408f1d92dda97d6f98d36707c5eb6b3b5ed9fbbce4143f6d", + "002/weaken_final_leakage_theorem/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "002/weaken_final_leakage_theorem/mutant-source.lean.txt": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "002/weaken_final_leakage_theorem/result.json": "8293ba459bb90648c0448890aae54d5d2b7c01cb09e8ee71d5a4e55e3cc5a1f6", + "003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "003/change_diagnostic_first_owner_update/mutant-source.lean.txt": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "003/change_diagnostic_first_owner_update/result.json": "685fd47652221dab5c0e1f79a0d989cc6207881665c43c39ccbe685a2dd8eed4", + "003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "003/drop_cross_conflict_stickiness/mutant-source.lean.txt": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "003/drop_cross_conflict_stickiness/result.json": "7b18e2919bfb7cd8fbf722edb1712539a6953cc86d811b8dc3f3d95f6f24e057", + "003/drop_historical_campaign_membership/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/drop_historical_campaign_membership/build-00-SplitModel.stdout": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "003/drop_historical_campaign_membership/mutant-source.lean.txt": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "003/drop_historical_campaign_membership/result.json": "d11211491d3439e7e9033ed21758a7b84404fd0ac18684f33a1fad8a9e3e101f", + "003/prohibited_project_axiom/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "003/prohibited_project_axiom/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-04-LeanAudit.stdout": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "003/prohibited_project_axiom/mutant-source.lean.txt": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "003/prohibited_project_axiom/result.json": "3f1374a1123f4b4bdbe49e6bd6dd8f71ba2932050b464f5f71c7968ce2364d43", + "003/prohibited_sorry/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-00-SplitModel.stdout": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "003/prohibited_sorry/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-04-LeanAudit.stdout": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "003/prohibited_sorry/mutant-source.lean.txt": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "003/prohibited_sorry/result.json": "0fc83b4837938c12c89bba62bb74070eda233d7ce44fa13a56a7073719e1197d", + "003/result.json": "6a2982ab558b83f472c60052c458055f30775d8e53d4f0a0015ff446d88d18dd", + "003/weaken_final_leakage_theorem/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "003/weaken_final_leakage_theorem/mutant-source.lean.txt": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "003/weaken_final_leakage_theorem/result.json": "65b7710a986a187cc2ed3d85878240fd22a59b4ce305b6ce3edc412b026768da" + }, + "nominal_proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "prior_failed_attempts": [ + "001", + "002" + ], + "schema": "sonification-mat009-lean-negative-archive-v1" +} diff --git a/formal/sonification/mat009/lean/verify_negative.py b/formal/sonification/mat009/lean/verify_negative.py new file mode 100644 index 0000000..bd36aae --- /dev/null +++ b/formal/sonification/mat009/lean/verify_negative.py @@ -0,0 +1,112 @@ +#!/usr/bin/env python3 +"""Bind all retained MAT009 Lean mutation attempts, including failures.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +DEFAULT_ARCHIVE = HERE / "negative" +MANIFEST_SHA256 = "6d99b5c41017d87922ffd01f3b34eccab692806ca38b760299371cbcc0d0750b" +BASELINE = "a09aab6572fb9c3875d5f2940bdb17ec55c358d5" +RUNNER_COMMIT = "5620029fb724ac41827a0c41c4c677b9594464f3" +EXPECTED_CASES = { + "drop_cross_conflict_stickiness", + "drop_historical_campaign_membership", + "weaken_final_leakage_theorem", + "change_diagnostic_first_owner_update", + "prohibited_project_axiom", + "prohibited_sorry", +} + + +def sha(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def require(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def verify(archive: Path = DEFAULT_ARCHIVE) -> dict: + path = archive / "ARCHIVE_MANIFEST.json" + require(path.is_file() and not path.is_symlink(), "missing negative archive manifest") + raw = path.read_bytes() + require(sha(raw) == MANIFEST_SHA256, "negative archive manifest changed") + manifest = json.loads(raw) + require(manifest["schema"] == "sonification-mat009-lean-negative-archive-v1" and + manifest["nominal_proof_input_commit"] == BASELINE and + manifest["accepted_attempt"] == "003" and + manifest["accepted_case_count"] == 6 and + manifest["prior_failed_attempts"] == ["001", "002"], + "negative archive identity changed") + files = manifest["files_sha256"] + observed = {str(p.relative_to(archive)) for p in archive.rglob("*") if p.is_file()} + require(observed == set(files) | {"ARCHIVE_MANIFEST.json"}, + "negative archive file inventory changed") + for name, digest in files.items(): + member = archive / name + require(member.is_file() and not member.is_symlink() and + sha(member.read_bytes()) == digest, f"altered negative evidence: {name}") + + prior1 = json.loads((archive / "001/result.json").read_text()) + prior2 = json.loads((archive / "002/result.json").read_text()) + require(prior1["status"] == "FAILED_DEVELOPMENT_ATTEMPT" and + prior1["exit_code"] != 0, "first failed attempt was rewritten") + require(prior2["status"] == "FAIL" and + sum(case["detected"] for case in prior2["cases"]) == 4, + "second failed attempt was rewritten") + + report = json.loads((archive / "003/result.json").read_text()) + require(report["status"] == "PASS" and + report["proof_input_commit"] == BASELINE and + report["negative_runner_commit"] == RUNNER_COMMIT and + report["negative_runner_sha256"] == sha((HERE / "negative.py").read_bytes()) and + report["REFINEMENT_PROVED"] == "OPEN", + "accepted negative execution identity changed") + require({row["mutation"] for row in report["cases"]} == EXPECTED_CASES and + len(report["cases"]) == len(EXPECTED_CASES) and + all(row["detected"] for row in report["cases"]), + "negative control coverage or result changed") + for summary in report["cases"]: + case = archive / "003" / summary["mutation"] + detail = json.loads((case / "result.json").read_text()) + require(detail["detected"] is True and + detail["mutation"] == summary["mutation"] and + detail["expected_failure_module"] == + detail["observed_failure_module"] == summary["observed_failure_module"], + f"negative case did not detect intended failure: {summary['mutation']}") + require(sha((case / "mutant-source.lean.txt").read_bytes()) == + detail["mutant_sha256"], + f"mutated proof source changed: {summary['mutation']}") + for index, job in enumerate(detail["commands"]): + module = job["argv"][-1].removesuffix(".lean") + label = f"build-{index:02d}-{module}" + for stream in ("stdout", "stderr"): + require(sha((case / f"{label}.{stream}").read_bytes()) == + job[f"{stream}_sha256"], + f"negative command stream changed: {summary['mutation']}/{label}") + require(job["timed_out"] is False and + (job["exit_code"] == 0 if index + 1 < len(detail["commands"]) + else job["exit_code"] != 0), + f"negative command exit changed: {summary['mutation']}/{label}") + module = detail["observed_failure_module"] + label = f"build-{len(detail['commands']) - 1:02d}-{module}" + output = ((case / f"{label}.stdout").read_text() + + (case / f"{label}.stderr").read_text()) + require(detail["expected_diagnostic_text"] in output, + f"negative case failed for an unrelated reason: {summary['mutation']}") + return {"status": "MAT009_NEGATIVE_EVIDENCE_BOUND", "detected": 6, + "failed_development_attempts_retained": 2, + "REFINEMENT_PROVED": "OPEN"} + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--archive", type=Path, default=DEFAULT_ARCHIVE) + args = parser.parse_args() + print(json.dumps(verify(args.archive), sort_keys=True)) diff --git a/tests/test_sonification_formal_mat009_negative_receipts.py b/tests/test_sonification_formal_mat009_negative_receipts.py new file mode 100644 index 0000000..e2d2524 --- /dev/null +++ b/tests/test_sonification_formal_mat009_negative_receipts.py @@ -0,0 +1,43 @@ +"""Mutation-archive integrity controls for MAT009 model evidence.""" + +from __future__ import annotations + +import shutil +import tempfile +import unittest +from pathlib import Path + +from formal.sonification.mat009.lean.verify_negative import DEFAULT_ARCHIVE, verify + + +class Mat009NegativeReceiptTests(unittest.TestCase): + def setUp(self) -> None: + self.temp = tempfile.TemporaryDirectory(prefix="mat009-negative-receipt-control-") + self.addCleanup(self.temp.cleanup) + self.archive = Path(self.temp.name) / "negative" + shutil.copytree(DEFAULT_ARCHIVE, self.archive) + + def test_intact_archive(self) -> None: + result = verify(self.archive) + self.assertEqual(result["status"], "MAT009_NEGATIVE_EVIDENCE_BOUND") + self.assertEqual(result["detected"], 6) + + def test_missing_mutant_source(self) -> None: + (self.archive / "003/weaken_final_leakage_theorem/mutant-source.lean.txt").unlink() + with self.assertRaisesRegex(ValueError, "archive file inventory changed"): + verify(self.archive) + + def test_altered_failed_proof_log(self) -> None: + log = self.archive / "003/prohibited_project_axiom/build-04-LeanAudit.stdout" + log.write_text("project axiom declaration detected\n") + with self.assertRaisesRegex(ValueError, "altered negative evidence"): + verify(self.archive) + + def test_missing_prior_failure_receipt(self) -> None: + (self.archive / "002/result.json").unlink() + with self.assertRaisesRegex(ValueError, "archive file inventory changed"): + verify(self.archive) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_sonification_formal_mat009_source_mutation.py b/tests/test_sonification_formal_mat009_source_mutation.py new file mode 100644 index 0000000..bdca91a --- /dev/null +++ b/tests/test_sonification_formal_mat009_source_mutation.py @@ -0,0 +1,45 @@ +"""Isolated source-blob mutation control for the MAT009 frozen-source binder.""" + +from __future__ import annotations + +import subprocess +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch + +from formal.sonification.mat009.source import source_bind + + +class Mat009SourceMutationTests(unittest.TestCase): + def test_changed_frozen_python_module_is_rejected(self) -> None: + with tempfile.TemporaryDirectory(prefix="mat009-source-mutation-") as temp: + checkout = Path(temp) / "frozen-checkout" + subprocess.run( + ["git", "worktree", "add", "--detach", str(checkout), source_bind.COMMIT], + cwd=source_bind.ROOT, check=True, capture_output=True, + ) + target = checkout / "materials/mat_spec_009.py" + original = target.read_bytes() + try: + with patch.object(source_bind, "ROOT", checkout): + self.assertEqual(source_bind.verify()["status"], "SOURCE_SYNTAX_MATCH") + mutant = original.replace( + b"CAMPAIGN_CROSSES_TRAIN_HOLDOUT", + b"CAMPAIGN_CROSSES_TRAIN_HOLDOUT_MUTANT", + 1, + ) + self.assertNotEqual(mutant, original) + target.write_bytes(mutant) + with self.assertRaisesRegex(ValueError, "working-tree target differs"): + source_bind.verify() + finally: + target.write_bytes(original) + subprocess.run( + ["git", "worktree", "remove", str(checkout)], + cwd=source_bind.ROOT, check=True, capture_output=True, + ) + + +if __name__ == "__main__": + unittest.main() From 94a357284408e6bc24cfb9b2d49e9d4144791042 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:38:47 +1030 Subject: [PATCH 12/22] formal(mat009): retain integrity tests and evidence-verifier executions --- .../mat009-integrity-tests-001/receipt.json | 39 ++++++++++++++++ .../mat009-integrity-tests-001/stderr.log | 4 ++ .../mat009-integrity-tests-001/stdout.log | 0 .../tracked-diff.patch | 0 .../worktree-status.txt | 0 .../receipt.json | 31 +++++++++++++ .../stderr.log | 0 .../stdout.log | 1 + .../tracked-diff.patch | 0 .../worktree-status.txt | 2 + .../receipt.json | 29 ++++++++++++ .../stderr.log | 0 .../stdout.log | 1 + .../tracked-diff.patch | 0 .../worktree-status.txt | 3 ++ .../receipt.json | 28 ++++++++++++ .../stderr.log | 0 .../stdout.log | 1 + .../tracked-diff.patch | 0 .../worktree-status.txt | 1 + .../evidence/mat009-ruff-all-001/receipt.json | 45 +++++++++++++++++++ .../evidence/mat009-ruff-all-001/stderr.log | 0 .../evidence/mat009-ruff-all-001/stdout.log | 1 + .../mat009-ruff-all-001/tracked-diff.patch | 0 .../mat009-ruff-all-001/worktree-status.txt | 4 ++ 25 files changed, 190 insertions(+) create mode 100644 formal/sonification/evidence/mat009-integrity-tests-001/receipt.json create mode 100644 formal/sonification/evidence/mat009-integrity-tests-001/stderr.log create mode 100644 formal/sonification/evidence/mat009-integrity-tests-001/stdout.log create mode 100644 formal/sonification/evidence/mat009-integrity-tests-001/tracked-diff.patch create mode 100644 formal/sonification/evidence/mat009-integrity-tests-001/worktree-status.txt create mode 100644 formal/sonification/evidence/mat009-retained-lean-verify-001/receipt.json create mode 100644 formal/sonification/evidence/mat009-retained-lean-verify-001/stderr.log create mode 100644 formal/sonification/evidence/mat009-retained-lean-verify-001/stdout.log create mode 100644 formal/sonification/evidence/mat009-retained-lean-verify-001/tracked-diff.patch create mode 100644 formal/sonification/evidence/mat009-retained-lean-verify-001/worktree-status.txt create mode 100644 formal/sonification/evidence/mat009-retained-negative-verify-001/receipt.json create mode 100644 formal/sonification/evidence/mat009-retained-negative-verify-001/stderr.log create mode 100644 formal/sonification/evidence/mat009-retained-negative-verify-001/stdout.log create mode 100644 formal/sonification/evidence/mat009-retained-negative-verify-001/tracked-diff.patch create mode 100644 formal/sonification/evidence/mat009-retained-negative-verify-001/worktree-status.txt create mode 100644 formal/sonification/evidence/mat009-retained-source-verify-001/receipt.json create mode 100644 formal/sonification/evidence/mat009-retained-source-verify-001/stderr.log create mode 100644 formal/sonification/evidence/mat009-retained-source-verify-001/stdout.log create mode 100644 formal/sonification/evidence/mat009-retained-source-verify-001/tracked-diff.patch create mode 100644 formal/sonification/evidence/mat009-retained-source-verify-001/worktree-status.txt create mode 100644 formal/sonification/evidence/mat009-ruff-all-001/receipt.json create mode 100644 formal/sonification/evidence/mat009-ruff-all-001/stderr.log create mode 100644 formal/sonification/evidence/mat009-ruff-all-001/stdout.log create mode 100644 formal/sonification/evidence/mat009-ruff-all-001/tracked-diff.patch create mode 100644 formal/sonification/evidence/mat009-ruff-all-001/worktree-status.txt diff --git a/formal/sonification/evidence/mat009-integrity-tests-001/receipt.json b/formal/sonification/evidence/mat009-integrity-tests-001/receipt.json new file mode 100644 index 0000000..80a8a48 --- /dev/null +++ b/formal/sonification/evidence/mat009-integrity-tests-001/receipt.json @@ -0,0 +1,39 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_sonification_formal_mat009_*.py", + "-q" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T01:07:49.901877+00:00", + "ended_utc": "2026-11-10T01:07:51.076219+00:00", + "exit_code": 0, + "checkout_commit": "b9a828695b56b9caf73acbee0a5c35c2e66b4bef", + "worktree_status": "CLEAN", + "inputs": { + "tests/test_sonification_formal_mat009_split.py": "beb02ce17f07807309e9cceba2a9e0dd6412dc578cc8362050890f38a5bdad73", + "tests/test_sonification_formal_mat009_receipts.py": "3bc91bcf7335de4c7d2c3f815ccc396085a8652e6d4b2c6b424c701854c6f78a", + "tests/test_sonification_formal_mat009_lean_receipts.py": "5ec12d741c59d46e240777cfe09e5cce7ea3684e83c8e7fc5eb881193982755f", + "tests/test_sonification_formal_mat009_negative_receipts.py": "87e1ed0a0d53c3b20f91fbe17f5672725ca9ad76a3befc4e2941bc8190cf4ecf", + "tests/test_sonification_formal_mat009_source_mutation.py": "afe6e19c7a044f97a9e8290f27c448ed9412665926852bc89d24918b0bc298bb" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_sha256": "c8a7a5b27b342575f22e09ae0b04898daa4b34d815ce40967dbc2934857df86d", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/evidence/mat009-integrity-tests-001/stderr.log b/formal/sonification/evidence/mat009-integrity-tests-001/stderr.log new file mode 100644 index 0000000..2fd0dee --- /dev/null +++ b/formal/sonification/evidence/mat009-integrity-tests-001/stderr.log @@ -0,0 +1,4 @@ +---------------------------------------------------------------------- +Ran 38 tests in 1.104s + +OK diff --git a/formal/sonification/evidence/mat009-integrity-tests-001/stdout.log b/formal/sonification/evidence/mat009-integrity-tests-001/stdout.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-integrity-tests-001/tracked-diff.patch b/formal/sonification/evidence/mat009-integrity-tests-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-integrity-tests-001/worktree-status.txt b/formal/sonification/evidence/mat009-integrity-tests-001/worktree-status.txt new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-retained-lean-verify-001/receipt.json b/formal/sonification/evidence/mat009-retained-lean-verify-001/receipt.json new file mode 100644 index 0000000..c44bc67 --- /dev/null +++ b/formal/sonification/evidence/mat009-retained-lean-verify-001/receipt.json @@ -0,0 +1,31 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "formal/sonification/mat009/lean/verify.py", + "--lean", + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T01:07:59.545117+00:00", + "ended_utc": "2026-11-10T01:08:00.163980+00:00", + "exit_code": 0, + "checkout_commit": "b9a828695b56b9caf73acbee0a5c35c2e66b4bef", + "worktree_status": "DIRTY", + "inputs": { + "formal/sonification/mat009/lean/verify.py": "d6239ba0a2bc2af1beedc7ea88e6a64a5af0a086e898427ebe9aaaffb96357ed", + "formal/sonification/mat009/lean/attempts/002/EVIDENCE_MANIFEST.json": "c068cb09fa08737a25bf49c17fa7cbca1e31dbbaa5ab388532b5529e1e41c817" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "c419e181e2b8bbecddb22cfbf98b41d848f22f725d939ecafcafaf326fea32d4", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/evidence/mat009-retained-lean-verify-001/stderr.log b/formal/sonification/evidence/mat009-retained-lean-verify-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-retained-lean-verify-001/stdout.log b/formal/sonification/evidence/mat009-retained-lean-verify-001/stdout.log new file mode 100644 index 0000000..5b9973f --- /dev/null +++ b/formal/sonification/evidence/mat009-retained-lean-verify-001/stdout.log @@ -0,0 +1 @@ +{"AUDIT_ACCEPTED": "OPEN", "REFINEMENT_PROVED": "OPEN", "named_model_theorems": 22, "status": "MAT009_LEAN_EVIDENCE_BOUND", "toolchain_imports": 1303} diff --git a/formal/sonification/evidence/mat009-retained-lean-verify-001/tracked-diff.patch b/formal/sonification/evidence/mat009-retained-lean-verify-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-retained-lean-verify-001/worktree-status.txt b/formal/sonification/evidence/mat009-retained-lean-verify-001/worktree-status.txt new file mode 100644 index 0000000..eaafb04 --- /dev/null +++ b/formal/sonification/evidence/mat009-retained-lean-verify-001/worktree-status.txt @@ -0,0 +1,2 @@ +?? formal/sonification/evidence/mat009-integrity-tests-001/ +?? formal/sonification/evidence/mat009-retained-source-verify-001/ diff --git a/formal/sonification/evidence/mat009-retained-negative-verify-001/receipt.json b/formal/sonification/evidence/mat009-retained-negative-verify-001/receipt.json new file mode 100644 index 0000000..b28bd8b --- /dev/null +++ b/formal/sonification/evidence/mat009-retained-negative-verify-001/receipt.json @@ -0,0 +1,29 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "formal/sonification/mat009/lean/verify_negative.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T01:08:09.470293+00:00", + "ended_utc": "2026-11-10T01:08:09.512634+00:00", + "exit_code": 0, + "checkout_commit": "b9a828695b56b9caf73acbee0a5c35c2e66b4bef", + "worktree_status": "DIRTY", + "inputs": { + "formal/sonification/mat009/lean/verify_negative.py": "1800c46d660b7c1e96d2db7aeb356c847cb143af59985f9a7ea23e719cb86b20", + "formal/sonification/mat009/lean/negative/ARCHIVE_MANIFEST.json": "6d99b5c41017d87922ffd01f3b34eccab692806ca38b760299371cbcc0d0750b" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "8cb3c759e0dd871f132cc1524700e3908fbc88e38b5b8e39901fcbd5d9f87c21", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/evidence/mat009-retained-negative-verify-001/stderr.log b/formal/sonification/evidence/mat009-retained-negative-verify-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-retained-negative-verify-001/stdout.log b/formal/sonification/evidence/mat009-retained-negative-verify-001/stdout.log new file mode 100644 index 0000000..b95b717 --- /dev/null +++ b/formal/sonification/evidence/mat009-retained-negative-verify-001/stdout.log @@ -0,0 +1 @@ +{"REFINEMENT_PROVED": "OPEN", "detected": 6, "failed_development_attempts_retained": 2, "status": "MAT009_NEGATIVE_EVIDENCE_BOUND"} diff --git a/formal/sonification/evidence/mat009-retained-negative-verify-001/tracked-diff.patch b/formal/sonification/evidence/mat009-retained-negative-verify-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-retained-negative-verify-001/worktree-status.txt b/formal/sonification/evidence/mat009-retained-negative-verify-001/worktree-status.txt new file mode 100644 index 0000000..a75e6ac --- /dev/null +++ b/formal/sonification/evidence/mat009-retained-negative-verify-001/worktree-status.txt @@ -0,0 +1,3 @@ +?? formal/sonification/evidence/mat009-integrity-tests-001/ +?? formal/sonification/evidence/mat009-retained-lean-verify-001/ +?? formal/sonification/evidence/mat009-retained-source-verify-001/ diff --git a/formal/sonification/evidence/mat009-retained-source-verify-001/receipt.json b/formal/sonification/evidence/mat009-retained-source-verify-001/receipt.json new file mode 100644 index 0000000..6ddc663 --- /dev/null +++ b/formal/sonification/evidence/mat009-retained-source-verify-001/receipt.json @@ -0,0 +1,28 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "formal/sonification/mat009/verify_evidence.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T01:07:55.480089+00:00", + "ended_utc": "2026-11-10T01:07:55.536583+00:00", + "exit_code": 0, + "checkout_commit": "b9a828695b56b9caf73acbee0a5c35c2e66b4bef", + "worktree_status": "DIRTY", + "inputs": { + "formal/sonification/mat009/verify_evidence.py": "6e0757983a146932d0f121032a3c660814831df30d1aa58657610dabec215332" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "2c408e885fa4ac144dbd6bffc148095f09f3e67db1fb054de95953589e56c816", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/evidence/mat009-retained-source-verify-001/stderr.log b/formal/sonification/evidence/mat009-retained-source-verify-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-retained-source-verify-001/stdout.log b/formal/sonification/evidence/mat009-retained-source-verify-001/stdout.log new file mode 100644 index 0000000..b965f29 --- /dev/null +++ b/formal/sonification/evidence/mat009-retained-source-verify-001/stdout.log @@ -0,0 +1 @@ +{"REFINEMENT_PROVED": "OPEN", "receipt_count": 4, "status": "MAT009_SOURCE_FINITE_RECEIPTS_BOUND"} diff --git a/formal/sonification/evidence/mat009-retained-source-verify-001/tracked-diff.patch b/formal/sonification/evidence/mat009-retained-source-verify-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-retained-source-verify-001/worktree-status.txt b/formal/sonification/evidence/mat009-retained-source-verify-001/worktree-status.txt new file mode 100644 index 0000000..df3f9c4 --- /dev/null +++ b/formal/sonification/evidence/mat009-retained-source-verify-001/worktree-status.txt @@ -0,0 +1 @@ +?? formal/sonification/evidence/mat009-integrity-tests-001/ diff --git a/formal/sonification/evidence/mat009-ruff-all-001/receipt.json b/formal/sonification/evidence/mat009-ruff-all-001/receipt.json new file mode 100644 index 0000000..dec2fd3 --- /dev/null +++ b/formal/sonification/evidence/mat009-ruff-all-001/receipt.json @@ -0,0 +1,45 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "uv", + "run", + "--no-project", + "--offline", + "--with", + "ruff", + "ruff", + "check", + "formal/sonification/mat009", + "tests/test_sonification_formal_mat009_lean_receipts.py", + "tests/test_sonification_formal_mat009_negative_receipts.py", + "tests/test_sonification_formal_mat009_receipts.py", + "tests/test_sonification_formal_mat009_source_mutation.py", + "tests/test_sonification_formal_mat009_split.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T01:08:20.603945+00:00", + "ended_utc": "2026-11-10T01:08:20.637613+00:00", + "exit_code": 0, + "checkout_commit": "b9a828695b56b9caf73acbee0a5c35c2e66b4bef", + "worktree_status": "DIRTY", + "inputs": { + "formal/sonification/mat009/lean/check.py": "125041442f582e7fc254dc341926b4cfb935ac964057c930021366a950a5a108", + "formal/sonification/mat009/lean/negative.py": "874ca7ff059394e97cc908d921dec51bbc0ff852c354baf1c8da7a7d557a352c", + "formal/sonification/mat009/lean/verify.py": "d6239ba0a2bc2af1beedc7ea88e6a64a5af0a086e898427ebe9aaaffb96357ed", + "formal/sonification/mat009/lean/verify_negative.py": "1800c46d660b7c1e96d2db7aeb356c847cb143af59985f9a7ea23e719cb86b20", + "formal/sonification/mat009/source/source_bind.py": "575ab1ea12186419bc6dbae31e12ae1e45d46a3b3c4a630b63e0a53853433beb", + "formal/sonification/mat009/verify_evidence.py": "6e0757983a146932d0f121032a3c660814831df30d1aa58657610dabec215332" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/home/trent/.local/bin/uv", + "command_executable_sha256": "92face6b1f0462ad911857957bd168cd4ae45515e2a2cb3fcc3ecbda3d4d82b1", + "stdout_sha256": "82b3e6a6c090a57601d22943bd23fca9218d1031dbe5a7b754092f9a156b4f18", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/evidence/mat009-ruff-all-001/stderr.log b/formal/sonification/evidence/mat009-ruff-all-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-ruff-all-001/stdout.log b/formal/sonification/evidence/mat009-ruff-all-001/stdout.log new file mode 100644 index 0000000..1f5f344 --- /dev/null +++ b/formal/sonification/evidence/mat009-ruff-all-001/stdout.log @@ -0,0 +1 @@ +All checks passed! diff --git a/formal/sonification/evidence/mat009-ruff-all-001/tracked-diff.patch b/formal/sonification/evidence/mat009-ruff-all-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-ruff-all-001/worktree-status.txt b/formal/sonification/evidence/mat009-ruff-all-001/worktree-status.txt new file mode 100644 index 0000000..8082499 --- /dev/null +++ b/formal/sonification/evidence/mat009-ruff-all-001/worktree-status.txt @@ -0,0 +1,4 @@ +?? formal/sonification/evidence/mat009-integrity-tests-001/ +?? formal/sonification/evidence/mat009-retained-lean-verify-001/ +?? formal/sonification/evidence/mat009-retained-negative-verify-001/ +?? formal/sonification/evidence/mat009-retained-source-verify-001/ From c9d2b6f5ee7b0a23b10b5cfd4c495b461ccb17c9 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:42:36 +1030 Subject: [PATCH 13/22] formal(mat009): retain full repository test run --- .../mat009-full-pytest-001/receipt.json | 28 +++++++++++++++++++ .../mat009-full-pytest-001/stderr.log | 0 .../mat009-full-pytest-001/stdout.log | 7 +++++ .../mat009-full-pytest-001/tracked-diff.patch | 0 .../worktree-status.txt | 0 5 files changed, 35 insertions(+) create mode 100644 formal/sonification/evidence/mat009-full-pytest-001/receipt.json create mode 100644 formal/sonification/evidence/mat009-full-pytest-001/stderr.log create mode 100644 formal/sonification/evidence/mat009-full-pytest-001/stdout.log create mode 100644 formal/sonification/evidence/mat009-full-pytest-001/tracked-diff.patch create mode 100644 formal/sonification/evidence/mat009-full-pytest-001/worktree-status.txt diff --git a/formal/sonification/evidence/mat009-full-pytest-001/receipt.json b/formal/sonification/evidence/mat009-full-pytest-001/receipt.json new file mode 100644 index 0000000..04036e5 --- /dev/null +++ b/formal/sonification/evidence/mat009-full-pytest-001/receipt.json @@ -0,0 +1,28 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "-m", + "pytest", + "-q" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T01:10:21.151479+00:00", + "ended_utc": "2026-11-10T01:12:21.837382+00:00", + "exit_code": 0, + "checkout_commit": "94a357284408e6bc24cfb9b2d49e9d4144791042", + "worktree_status": "CLEAN", + "inputs": {}, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "31f40469e07bb9d0da2a4e7c18cce59ee83d4b1e5243095535d76f212c6d4c8a", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/evidence/mat009-full-pytest-001/stderr.log b/formal/sonification/evidence/mat009-full-pytest-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-full-pytest-001/stdout.log b/formal/sonification/evidence/mat009-full-pytest-001/stdout.log new file mode 100644 index 0000000..8d36c4a --- /dev/null +++ b/formal/sonification/evidence/mat009-full-pytest-001/stdout.log @@ -0,0 +1,7 @@ +........................................................................ [ 21%] +........................................ [ 34%] +.......................................... [ 46%] +............................................................................................................. [ 79%] +............................................... [ 94%] +................... [100%] +329 passed, 202 subtests passed in 120.37s (0:02:00) diff --git a/formal/sonification/evidence/mat009-full-pytest-001/tracked-diff.patch b/formal/sonification/evidence/mat009-full-pytest-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/evidence/mat009-full-pytest-001/worktree-status.txt b/formal/sonification/evidence/mat009-full-pytest-001/worktree-status.txt new file mode 100644 index 0000000..e69de29 From 49cf9575c648f3c1aedaa59b1bae852a196d5d29 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:53:26 +1030 Subject: [PATCH 14/22] formal(mat009): preserve independent audit and detected trust-gate defect --- .../mat009/audit/archive-integrity-001.json | 64 + .../mat009/audit/archive_integrity.py | 196 + .../mat009/audit/archive_integrity.stderr | 0 .../mat009/audit/archive_integrity.stdout | 1 + .../mat009/audit/checker-replay-001.stderr | 0 .../mat009/audit/checker-replay-001.stdout | 1 + .../build-00-SplitModel.json | 15 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.json | 15 + .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.json | 15 + .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.json | 15 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.json | 15 + .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1664 ++++++ .../checker-replay-001/declarations.json | 3321 +++++++++++ .../checker-replay-001/lean-version.json | 12 + .../checker-replay-001/lean-version.stderr | 0 .../checker-replay-001/lean-version.stdout | 1 + .../checker-replay-001/named-axioms.json | 62 + .../audit/checker-replay-001/result.json | 55 + .../checker-replay-001/theorem-types.json | 24 + .../checker-replay-001/toolchain-imports.json | 5214 +++++++++++++++++ .../mat009/audit/checker_mutant_driver.py | 34 + .../mat009/audit/count_gate.stderr | 10 + .../mat009/audit/count_gate.stdout | 0 .../mat009/audit/count_gate_driver.py | 26 + .../mat009/audit/independent-cpython-001.json | 28 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1664 ++++++ .../independent-axioms.json | 74 + .../independent-axioms.stderr | 0 .../independent-axioms.stdout | 22 + .../lean-version.stderr | 0 .../lean-version.stdout | 1 + .../audit/independent-replay-001/result.json | 128 + .../work/DiagnosticFirstOwner.lean | 78 + .../work/ExactTypes.lean | 98 + .../work/IndependentAxioms.lean | 23 + .../work/LeanAudit.lean | 66 + .../work/SplitModel.lean | 379 ++ .../work/TypedConsumer.lean | 65 + .../mat009/audit/independent_cpython.py | 197 + .../mat009/audit/independent_cpython.stderr | 0 .../mat009/audit/independent_cpython.stdout | 1 + .../mat009/audit/independent_replay.py | 198 + .../mat009/audit/independent_replay.stderr | 0 .../mat009/audit/independent_replay.stdout | 1 + .../sonification/mat009/audit/make_report.py | 357 ++ .../mat009/audit/make_report.stderr | 0 .../mat009/audit/make_report.stdout | 1 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1666 ++++++ .../mutant-source.lean.txt | 382 ++ .../auxiliary_named_false_axiom/result.json | 106 + .../work/DiagnosticFirstOwner.lean | 78 + .../work/ExactTypes.lean | 98 + .../work/LeanAudit.lean | 66 + .../work/SplitModel.lean | 382 ++ .../work/TypedConsumer.lean | 65 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1467 +++++ .../mutant-source.lean.txt | 381 ++ .../ordinary_false_axiom/result.json | 79 + .../work/DiagnosticFirstOwner.lean | 78 + .../ordinary_false_axiom/work/ExactTypes.lean | 98 + .../ordinary_false_axiom/work/LeanAudit.lean | 66 + .../ordinary_false_axiom/work/SplitModel.lean | 381 ++ .../work/TypedConsumer.lean | 65 + .../audit/negative-probe-001/result.json | 28 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 68 + .../mutant-source.lean.txt | 369 ++ .../weaken_final_leakage/result.json | 51 + .../work/DiagnosticFirstOwner.lean | 78 + .../weaken_final_leakage/work/ExactTypes.lean | 98 + .../weaken_final_leakage/work/LeanAudit.lean | 66 + .../weaken_final_leakage/work/SplitModel.lean | 369 ++ .../work/TypedConsumer.lean | 65 + .../mat009/audit/negative_probe.py | 147 + .../mat009/audit/negative_probe.stderr | 0 .../mat009/audit/negative_probe.stdout | 1 + .../mat009/audit/nominal-finite.stderr | 4 + .../mat009/audit/nominal-finite.stdout | 0 .../mat009/audit/nominal-lean-receipt.stderr | 0 .../mat009/audit/nominal-lean-receipt.stdout | 1 + .../audit/nominal-negative-receipt.stderr | 0 .../audit/nominal-negative-receipt.stdout | 1 + .../audit/nominal-source-binding.stderr | 0 .../audit/nominal-source-binding.stdout | 1 + .../audit/nominal-source-receipts.stderr | 0 .../audit/nominal-source-receipts.stdout | 1 + formal/sonification/mat009/audit/report.json | 827 +++ .../mat009/audit/source_drift_driver.py | 35 + .../lean-attempt/EVIDENCE_MANIFEST.json | 30 + .../lean-attempt/build-00-SplitModel.json | 15 + .../lean-attempt/build-00-SplitModel.stderr | 0 .../lean-attempt/build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.json | 15 + .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../lean-attempt/build-02-TypedConsumer.json | 15 + .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../lean-attempt/build-03-ExactTypes.json | 15 + .../lean-attempt/build-03-ExactTypes.stderr | 0 .../lean-attempt/build-04-LeanAudit.json | 15 + .../lean-attempt/build-04-LeanAudit.stderr | 0 .../lean-attempt/build-04-LeanAudit.stdout | 1664 ++++++ .../lean-attempt/declarations.json | 3321 +++++++++++ .../lean-attempt/lean-version.json | 12 + .../lean-attempt/lean-version.stderr | 0 .../lean-attempt/lean-version.stdout | 1 + .../lean-attempt/named-axioms.json | 62 + .../lean-attempt/result.json | 55 + .../lean-attempt/theorem-types.json | 24 + .../lean-attempt/toolchain-imports.json | 5214 +++++++++++++++++ .../missing-finite-stream.stderr | 7 + .../missing-finite-stream.stdout | 0 .../missing-lean-stream.stderr | 12 + .../missing-lean-stream.stdout | 0 .../missing-negative-mutant.stderr | 12 + .../missing-negative-mutant.stdout | 0 .../mutated-proof-checker.stderr | 4 + .../mutated-proof-checker.stdout | 0 .../mutated-source.stderr | 4 + .../mutated-source.stdout | 0 .../negative-archive/001/result.json | 17 + .../negative-archive/001/runner.stderr | 17 + .../negative-archive/001/runner.stdout | 0 .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 17 + .../mutant-source.lean.txt | 78 + .../result.json | 37 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 29 + .../mutant-source.lean.txt | 379 ++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 42 + .../mutant-source.lean.txt | 379 ++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1493 +++++ .../mutant-source.lean.txt | 381 ++ .../002/prohibited_project_axiom/result.json | 76 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 1 + .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1500 +++++ .../prohibited_sorry/mutant-source.lean.txt | 381 ++ .../002/prohibited_sorry/result.json | 76 + .../negative-archive/002/result.json | 47 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 68 + .../mutant-source.lean.txt | 369 ++ .../weaken_final_leakage_theorem/result.json | 50 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 17 + .../mutant-source.lean.txt | 78 + .../result.json | 37 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 29 + .../mutant-source.lean.txt | 379 ++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 42 + .../mutant-source.lean.txt | 379 ++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1493 +++++ .../mutant-source.lean.txt | 381 ++ .../003/prohibited_project_axiom/result.json | 76 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 1 + .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1500 +++++ .../prohibited_sorry/mutant-source.lean.txt | 381 ++ .../003/prohibited_sorry/result.json | 76 + .../negative-archive/003/result.json | 47 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 68 + .../weaken_final_leakage_theorem/result.json | 50 + .../negative-archive/ARCHIVE_MANIFEST.json | 109 + .../audit/verification-probe-001/result.json | 85 + .../source-drift/materials/mat_spec_008.py | 625 ++ .../source-drift/materials/mat_spec_009.py | 541 ++ .../mat009-finite-001/receipt.json | 36 + .../mat009-finite-001/stdout.log | 0 .../mat009-finite-001/tracked-diff.patch | 0 .../mat009-finite-001/worktree-status.txt | 2 + .../mat009-pytest-001/receipt.json | 34 + .../mat009-pytest-001/stderr.log | 0 .../mat009-pytest-001/stdout.log | 2 + .../mat009-pytest-001/tracked-diff.patch | 0 .../mat009-pytest-001/worktree-status.txt | 4 + .../mat009-ruff-source-001/receipt.json | 37 + .../mat009-ruff-source-001/stderr.log | 0 .../mat009-ruff-source-001/stdout.log | 1 + .../mat009-ruff-source-001/tracked-diff.patch | 0 .../worktree-status.txt | 3 + .../mat009-source-bind-001/receipt.json | 29 + .../mat009-source-bind-001/stderr.log | 0 .../mat009-source-bind-001/stdout.log | 1 + .../mat009-source-bind-001/tracked-diff.patch | 0 .../worktree-status.txt | 0 .../checker-result/result.json | 11 + .../lean-attempt/EVIDENCE_MANIFEST.json | 30 + .../lean-attempt/build-00-SplitModel.json | 15 + .../lean-attempt/build-00-SplitModel.stderr | 0 .../lean-attempt/build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.json | 15 + .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../lean-attempt/build-02-TypedConsumer.json | 15 + .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../lean-attempt/build-03-ExactTypes.json | 15 + .../lean-attempt/build-03-ExactTypes.stderr | 0 .../lean-attempt/build-04-LeanAudit.json | 15 + .../lean-attempt/build-04-LeanAudit.stderr | 0 .../lean-attempt/build-04-LeanAudit.stdout | 1664 ++++++ .../lean-attempt/declarations.json | 3321 +++++++++++ .../lean-attempt/lean-version.json | 12 + .../lean-attempt/lean-version.stderr | 0 .../lean-attempt/lean-version.stdout | 1 + .../lean-attempt/named-axioms.json | 62 + .../lean-attempt/result.json | 55 + .../lean-attempt/theorem-types.json | 24 + .../lean-attempt/toolchain-imports.json | 5214 +++++++++++++++++ .../missing-finite-stream.stderr | 7 + .../missing-finite-stream.stdout | 0 .../missing-lean-stream.stderr | 12 + .../missing-lean-stream.stdout | 0 .../missing-negative-mutant.stderr | 12 + .../missing-negative-mutant.stdout | 0 .../mutated-proof-checker.stderr | 0 .../mutated-proof-checker.stdout | 1 + .../mutated-source.stderr | 15 + .../mutated-source.stdout | 0 .../negative-archive/001/result.json | 17 + .../negative-archive/001/runner.stderr | 17 + .../negative-archive/001/runner.stdout | 0 .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 17 + .../mutant-source.lean.txt | 78 + .../result.json | 37 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 29 + .../mutant-source.lean.txt | 379 ++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 42 + .../mutant-source.lean.txt | 379 ++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1493 +++++ .../mutant-source.lean.txt | 381 ++ .../002/prohibited_project_axiom/result.json | 76 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 1 + .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1500 +++++ .../prohibited_sorry/mutant-source.lean.txt | 381 ++ .../002/prohibited_sorry/result.json | 76 + .../negative-archive/002/result.json | 47 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 68 + .../mutant-source.lean.txt | 369 ++ .../weaken_final_leakage_theorem/result.json | 50 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 17 + .../mutant-source.lean.txt | 78 + .../result.json | 37 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 29 + .../mutant-source.lean.txt | 379 ++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 42 + .../mutant-source.lean.txt | 379 ++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1493 +++++ .../mutant-source.lean.txt | 381 ++ .../003/prohibited_project_axiom/result.json | 76 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 1 + .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1500 +++++ .../prohibited_sorry/mutant-source.lean.txt | 381 ++ .../003/prohibited_sorry/result.json | 76 + .../negative-archive/003/result.json | 47 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 68 + .../weaken_final_leakage_theorem/result.json | 50 + .../negative-archive/ARCHIVE_MANIFEST.json | 109 + .../audit/verification-probe-002/result.json | 85 + .../source-drift/materials/mat_spec_008.py | 625 ++ .../source-drift/materials/mat_spec_009.py | 541 ++ .../mat009-finite-001/receipt.json | 36 + .../mat009-finite-001/stdout.log | 0 .../mat009-finite-001/tracked-diff.patch | 0 .../mat009-finite-001/worktree-status.txt | 2 + .../mat009-pytest-001/receipt.json | 34 + .../mat009-pytest-001/stderr.log | 0 .../mat009-pytest-001/stdout.log | 2 + .../mat009-pytest-001/tracked-diff.patch | 0 .../mat009-pytest-001/worktree-status.txt | 4 + .../mat009-ruff-source-001/receipt.json | 37 + .../mat009-ruff-source-001/stderr.log | 0 .../mat009-ruff-source-001/stdout.log | 1 + .../mat009-ruff-source-001/tracked-diff.patch | 0 .../worktree-status.txt | 3 + .../mat009-source-bind-001/receipt.json | 29 + .../mat009-source-bind-001/stderr.log | 0 .../mat009-source-bind-001/stdout.log | 1 + .../mat009-source-bind-001/tracked-diff.patch | 0 .../worktree-status.txt | 0 .../mat009/audit/verification_probe.py | 145 + .../mat009/audit/verification_probe.stderr | 0 .../mat009/audit/verification_probe.stdout | 1 + .../audit/verification_probe_002.stderr | 0 .../audit/verification_probe_002.stdout | 1 + 438 files changed, 68115 insertions(+) create mode 100644 formal/sonification/mat009/audit/archive-integrity-001.json create mode 100644 formal/sonification/mat009/audit/archive_integrity.py create mode 100644 formal/sonification/mat009/audit/archive_integrity.stderr create mode 100644 formal/sonification/mat009/audit/archive_integrity.stdout create mode 100644 formal/sonification/mat009/audit/checker-replay-001.stderr create mode 100644 formal/sonification/mat009/audit/checker-replay-001.stdout create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-00-SplitModel.json create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-01-DiagnosticFirstOwner.json create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-02-TypedConsumer.json create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-03-ExactTypes.json create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-04-LeanAudit.json create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/checker-replay-001/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/checker-replay-001/declarations.json create mode 100644 formal/sonification/mat009/audit/checker-replay-001/lean-version.json create mode 100644 formal/sonification/mat009/audit/checker-replay-001/lean-version.stderr create mode 100644 formal/sonification/mat009/audit/checker-replay-001/lean-version.stdout create mode 100644 formal/sonification/mat009/audit/checker-replay-001/named-axioms.json create mode 100644 formal/sonification/mat009/audit/checker-replay-001/result.json create mode 100644 formal/sonification/mat009/audit/checker-replay-001/theorem-types.json create mode 100644 formal/sonification/mat009/audit/checker-replay-001/toolchain-imports.json create mode 100644 formal/sonification/mat009/audit/checker_mutant_driver.py create mode 100644 formal/sonification/mat009/audit/count_gate.stderr create mode 100644 formal/sonification/mat009/audit/count_gate.stdout create mode 100644 formal/sonification/mat009/audit/count_gate_driver.py create mode 100644 formal/sonification/mat009/audit/independent-cpython-001.json create mode 100644 formal/sonification/mat009/audit/independent-replay-001/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/independent-replay-001/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/independent-replay-001/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/independent-replay-001/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/independent-replay-001/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/independent-replay-001/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/independent-replay-001/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/independent-replay-001/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/independent-replay-001/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/independent-replay-001/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/independent-replay-001/independent-axioms.json create mode 100644 formal/sonification/mat009/audit/independent-replay-001/independent-axioms.stderr create mode 100644 formal/sonification/mat009/audit/independent-replay-001/independent-axioms.stdout create mode 100644 formal/sonification/mat009/audit/independent-replay-001/lean-version.stderr create mode 100644 formal/sonification/mat009/audit/independent-replay-001/lean-version.stdout create mode 100644 formal/sonification/mat009/audit/independent-replay-001/result.json create mode 100644 formal/sonification/mat009/audit/independent-replay-001/work/DiagnosticFirstOwner.lean create mode 100644 formal/sonification/mat009/audit/independent-replay-001/work/ExactTypes.lean create mode 100644 formal/sonification/mat009/audit/independent-replay-001/work/IndependentAxioms.lean create mode 100644 formal/sonification/mat009/audit/independent-replay-001/work/LeanAudit.lean create mode 100644 formal/sonification/mat009/audit/independent-replay-001/work/SplitModel.lean create mode 100644 formal/sonification/mat009/audit/independent-replay-001/work/TypedConsumer.lean create mode 100644 formal/sonification/mat009/audit/independent_cpython.py create mode 100644 formal/sonification/mat009/audit/independent_cpython.stderr create mode 100644 formal/sonification/mat009/audit/independent_cpython.stdout create mode 100644 formal/sonification/mat009/audit/independent_replay.py create mode 100644 formal/sonification/mat009/audit/independent_replay.stderr create mode 100644 formal/sonification/mat009/audit/independent_replay.stdout create mode 100644 formal/sonification/mat009/audit/make_report.py create mode 100644 formal/sonification/mat009/audit/make_report.stderr create mode 100644 formal/sonification/mat009/audit/make_report.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/result.json create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/DiagnosticFirstOwner.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/ExactTypes.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/LeanAudit.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/SplitModel.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/TypedConsumer.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/result.json create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/DiagnosticFirstOwner.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/ExactTypes.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/LeanAudit.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/SplitModel.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/TypedConsumer.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/result.json create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/result.json create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/DiagnosticFirstOwner.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/ExactTypes.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/LeanAudit.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/SplitModel.lean create mode 100644 formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/TypedConsumer.lean create mode 100644 formal/sonification/mat009/audit/negative_probe.py create mode 100644 formal/sonification/mat009/audit/negative_probe.stderr create mode 100644 formal/sonification/mat009/audit/negative_probe.stdout create mode 100644 formal/sonification/mat009/audit/nominal-finite.stderr create mode 100644 formal/sonification/mat009/audit/nominal-finite.stdout create mode 100644 formal/sonification/mat009/audit/nominal-lean-receipt.stderr create mode 100644 formal/sonification/mat009/audit/nominal-lean-receipt.stdout create mode 100644 formal/sonification/mat009/audit/nominal-negative-receipt.stderr create mode 100644 formal/sonification/mat009/audit/nominal-negative-receipt.stdout create mode 100644 formal/sonification/mat009/audit/nominal-source-binding.stderr create mode 100644 formal/sonification/mat009/audit/nominal-source-binding.stdout create mode 100644 formal/sonification/mat009/audit/nominal-source-receipts.stderr create mode 100644 formal/sonification/mat009/audit/nominal-source-receipts.stdout create mode 100644 formal/sonification/mat009/audit/report.json create mode 100644 formal/sonification/mat009/audit/source_drift_driver.py create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/EVIDENCE_MANIFEST.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-00-SplitModel.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-01-DiagnosticFirstOwner.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-02-TypedConsumer.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-03-ExactTypes.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-04-LeanAudit.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/declarations.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/lean-version.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/lean-version.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/lean-version.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/named-axioms.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/theorem-types.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/lean-attempt/toolchain-imports.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/missing-finite-stream.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/missing-finite-stream.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/missing-lean-stream.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/missing-lean-stream.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/missing-negative-mutant.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/missing-negative-mutant.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/mutated-proof-checker.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/mutated-proof-checker.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/mutated-source.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/mutated-source.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/001/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/001/runner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/001/runner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/negative-archive/ARCHIVE_MANIFEST.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-drift/materials/mat_spec_008.py create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-drift/materials/mat_spec_009.py create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/receipt.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/stdout.log create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/tracked-diff.patch create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/worktree-status.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/receipt.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/stderr.log create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/stdout.log create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/tracked-diff.patch create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/worktree-status.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/receipt.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/stderr.log create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/stdout.log create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/tracked-diff.patch create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/worktree-status.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/receipt.json create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/stderr.log create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/stdout.log create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/tracked-diff.patch create mode 100644 formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/worktree-status.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/checker-result/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/EVIDENCE_MANIFEST.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-00-SplitModel.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-01-DiagnosticFirstOwner.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-02-TypedConsumer.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-03-ExactTypes.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-04-LeanAudit.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/declarations.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/lean-version.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/lean-version.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/lean-version.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/named-axioms.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/theorem-types.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/lean-attempt/toolchain-imports.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/missing-finite-stream.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/missing-finite-stream.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/missing-lean-stream.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/missing-lean-stream.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/missing-negative-mutant.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/missing-negative-mutant.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/mutated-proof-checker.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/mutated-proof-checker.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/mutated-source.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/mutated-source.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/001/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/001/runner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/001/runner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/negative-archive/ARCHIVE_MANIFEST.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/result.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-drift/materials/mat_spec_008.py create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-drift/materials/mat_spec_009.py create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/receipt.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/stdout.log create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/tracked-diff.patch create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/worktree-status.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/receipt.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/stderr.log create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/stdout.log create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/tracked-diff.patch create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/worktree-status.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/receipt.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/stderr.log create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/stdout.log create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/tracked-diff.patch create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/worktree-status.txt create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/receipt.json create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/stderr.log create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/stdout.log create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/tracked-diff.patch create mode 100644 formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/worktree-status.txt create mode 100644 formal/sonification/mat009/audit/verification_probe.py create mode 100644 formal/sonification/mat009/audit/verification_probe.stderr create mode 100644 formal/sonification/mat009/audit/verification_probe.stdout create mode 100644 formal/sonification/mat009/audit/verification_probe_002.stderr create mode 100644 formal/sonification/mat009/audit/verification_probe_002.stdout diff --git a/formal/sonification/mat009/audit/archive-integrity-001.json b/formal/sonification/mat009/audit/archive-integrity-001.json new file mode 100644 index 0000000..627bf32 --- /dev/null +++ b/formal/sonification/mat009/audit/archive-integrity-001.json @@ -0,0 +1,64 @@ +{ + "cpython_refinement": "OPEN", + "failed_development_attempts_retained": 2, + "full_pytest_exit_code": 0, + "full_pytest_inputs_explicitly_listed": 0, + "full_pytest_receipt_sha256": "e2cb426b7ce15ccac76a5959dc9997c30fbb573fa5b17f1dd96f4a5adc0d0d3e", + "full_pytest_reported": "329 passed, 202 subtests passed", + "full_pytest_stdout_sha256": "31f40469e07bb9d0da2a4e7c18cce59ee83d4b1e5243095535d76f212c6d4c8a", + "negative_cases": { + "change_diagnostic_first_owner_update": { + "exit_code": 1, + "module": "DiagnosticFirstOwner" + }, + "drop_cross_conflict_stickiness": { + "exit_code": 1, + "module": "SplitModel" + }, + "drop_historical_campaign_membership": { + "exit_code": 1, + "module": "SplitModel" + }, + "prohibited_project_axiom": { + "exit_code": 1, + "module": "LeanAudit" + }, + "prohibited_sorry": { + "exit_code": 1, + "module": "LeanAudit" + }, + "weaken_final_leakage_theorem": { + "exit_code": 1, + "module": "TypedConsumer" + } + }, + "negative_file_count": 97, + "negative_manifest_sha256": "6d99b5c41017d87922ffd01f3b34eccab692806ca38b760299371cbcc0d0750b", + "nominal_audit_stdout_matches_independent_replay": true, + "nominal_file_count": 23, + "nominal_manifest_sha256": "c068cb09fa08737a25bf49c17fa7cbca1e31dbbaa5ab388532b5529e1e41c817", + "source_receipts": { + "mat009-finite-001": { + "exit_code": 0, + "input_count": 2, + "receipt_sha256": "b86b0b4ee2119ff0afffbd6ec575d9f2f3304fe6aaaa90cf3d6c43cae50f05e9" + }, + "mat009-pytest-001": { + "exit_code": 0, + "input_count": 3, + "receipt_sha256": "cd00d1ebda66b847432194d9b53ffa22060bfa518c6c6b99dc9e63ea1fe0996f" + }, + "mat009-ruff-source-001": { + "exit_code": 0, + "input_count": 2, + "receipt_sha256": "efe30f79371ca762ac498a06e7e49c7b330b644d6b8bcb2cfbc37a7e60c0b4fd" + }, + "mat009-source-bind-001": { + "exit_code": 0, + "input_count": 2, + "receipt_sha256": "e3c3793f25532f540ba20b79729c5f20ede2398470ed2ffa8d75705cb93c5606" + } + }, + "status": "PASS", + "toolchain_import_count": 1303 +} diff --git a/formal/sonification/mat009/audit/archive_integrity.py b/formal/sonification/mat009/audit/archive_integrity.py new file mode 100644 index 0000000..3a5c9ed --- /dev/null +++ b/formal/sonification/mat009/audit/archive_integrity.py @@ -0,0 +1,196 @@ +#!/usr/bin/env python3 +"""Recompute retained MAT009 archive digests and inspect original job streams.""" + +from __future__ import annotations + +import hashlib +import json +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[4] +AUDIT = Path(__file__).resolve().parent +PROOF = ROOT / "formal/sonification/mat009/lean" +EVIDENCE = ROOT / "formal/sonification/evidence" +OUT = AUDIT / "archive-integrity-001.json" +BASELINE = "a09aab6572fb9c3875d5f2940bdb17ec55c358d5" +SOURCE_CHECKPOINT = "38b5f9e99a5ce3f267c004362acf00ac0dc11342" +LEAN = Path("/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean") + + +def sha(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def read(path: Path) -> bytes: + assert path.is_file() and not path.is_symlink(), path + return path.read_bytes() + + +def check_manifest(directory: Path, expected_digest: str, filename: str) -> tuple[dict, int]: + manifest = directory / filename + raw = read(manifest) + assert sha(raw) == expected_digest, manifest + parsed = json.loads(raw) + files = parsed["files_sha256"] + observed = {str(path.relative_to(directory)) for path in directory.rglob("*") if path.is_file()} + assert observed == set(files) | {filename}, directory + for name, digest in files.items(): + assert sha(read(directory / name)) == digest, name + return parsed, len(files) + + +def main() -> int: + attempt = PROOF / "attempts/002" + manifest, files = check_manifest( + attempt, + "c068cb09fa08737a25bf49c17fa7cbca1e31dbbaa5ab388532b5529e1e41c817", + "EVIDENCE_MANIFEST.json", + ) + assert manifest["proof_input_commit"] == BASELINE + nominal = json.loads(read(attempt / "result.json")) + assert nominal["status"] == "PASS" and nominal["REFINEMENT_PROVED"] == "OPEN" + assert sha(read(LEAN)) == nominal["lean_executable_sha256"] + for filename, digest in nominal["input_sha256"].items(): + relative = f"formal/sonification/mat009/lean/{filename}" + assert sha(read(ROOT / relative)) == digest + historical = subprocess.check_output(["git", "show", f"{BASELINE}:{relative}"], cwd=ROOT) + assert sha(historical) == digest + for label in ( + "lean-version", + "build-00-SplitModel", + "build-01-DiagnosticFirstOwner", + "build-02-TypedConsumer", + "build-03-ExactTypes", + "build-04-LeanAudit", + ): + job = json.loads(read(attempt / f"{label}.json")) + assert job["exit_code"] == 0 and not job["timed_out"] + for stream in ("stdout", "stderr"): + assert sha(read(attempt / f"{label}.{stream}")) == job[f"{stream}_sha256"] + original_audit = read(attempt / "build-04-LeanAudit.stdout") + independent_audit = read(AUDIT / "independent-replay-001/build-04-LeanAudit.stdout") + assert original_audit == independent_audit + imports = json.loads(read(attempt / "toolchain-imports.json")) + assert len(imports) == 1303 + toolchain = LEAN.parent.parent + for module, record in imports.items(): + relative = Path("lib/lean") / (module.replace(".", "/") + ".olean") + assert str(relative) == record["relative_path"] + assert sha(read(toolchain / relative)) == record["sha256"] + + negative = PROOF / "negative" + neg_manifest, neg_files = check_manifest( + negative, + "6d99b5c41017d87922ffd01f3b34eccab692806ca38b760299371cbcc0d0750b", + "ARCHIVE_MANIFEST.json", + ) + assert neg_manifest["nominal_proof_input_commit"] == BASELINE + prior1 = json.loads(read(negative / "001/result.json")) + prior2 = json.loads(read(negative / "002/result.json")) + assert prior1["status"] == "FAILED_DEVELOPMENT_ATTEMPT" and prior1["exit_code"] != 0 + assert prior2["status"] == "FAIL" and sum(x["detected"] for x in prior2["cases"]) == 4 + negative_result = json.loads(read(negative / "003/result.json")) + assert negative_result["status"] == "PASS" and len(negative_result["cases"]) == 6 + cases = {} + for item in negative_result["cases"]: + name = item["mutation"] + path = negative / "003" / name + detail = json.loads(read(path / "result.json")) + assert detail["detected"] and item["detected"] + assert ( + detail["mutation"] == name + and detail["observed_failure_module"] == item["observed_failure_module"] + ) + assert sha(read(path / "mutant-source.lean.txt")) == detail["mutant_sha256"] + for index, job in enumerate(detail["commands"]): + module = job["argv"][-1].removesuffix(".lean") + label = f"build-{index:02d}-{module}" + for stream in ("stdout", "stderr"): + assert sha(read(path / f"{label}.{stream}")) == job[f"{stream}_sha256"] + assert job["exit_code"] == (0 if index + 1 < len(detail["commands"]) else 1) + assert not job["timed_out"] + final = detail["commands"][-1] + label = f"build-{len(detail['commands']) - 1:02d}-{detail['observed_failure_module']}" + output = read(path / f"{label}.stdout") + read(path / f"{label}.stderr") + assert detail["expected_diagnostic_text"].encode() in output + cases[name] = {"module": detail["observed_failure_module"], "exit_code": final["exit_code"]} + + receipt_names = ( + "mat009-source-bind-001", + "mat009-finite-001", + "mat009-ruff-source-001", + "mat009-pytest-001", + ) + receipts = {} + for name in receipt_names: + directory = EVIDENCE / name + assert {p.name for p in directory.iterdir()} == { + "receipt.json", + "stdout.log", + "stderr.log", + "worktree-status.txt", + "tracked-diff.patch", + } + receipt = json.loads(read(directory / "receipt.json")) + assert receipt["checkout_commit"] == SOURCE_CHECKPOINT and receipt["exit_code"] == 0 + assert read(directory / "tracked-diff.patch") == b"" + for stream in ("stdout", "stderr"): + assert sha(read(directory / f"{stream}.log")) == receipt[f"{stream}_sha256"] + for relative, digest in receipt["inputs"].items(): + assert sha(read(ROOT / relative)) == digest + historical = subprocess.check_output( + ["git", "show", f"{SOURCE_CHECKPOINT}:{relative}"], + cwd=ROOT, + ) + assert sha(historical) == digest + receipts[name] = { + "receipt_sha256": sha(read(directory / "receipt.json")), + "exit_code": receipt["exit_code"], + "input_count": len(receipt["inputs"]), + } + + full = EVIDENCE / "mat009-full-pytest-001" + full_receipt = json.loads(read(full / "receipt.json")) + assert full_receipt["checkout_commit"] == "94a357284408e6bc24cfb9b2d49e9d4144791042" + assert full_receipt["exit_code"] == 0 and full_receipt["inputs"] == {} + assert full_receipt["argv"] == ["python3", "-m", "pytest", "-q"] + assert sha(read(full / "stdout.log")) == full_receipt["stdout_sha256"] + assert sha(read(full / "stderr.log")) == full_receipt["stderr_sha256"] + assert b"329 passed, 202 subtests passed" in read(full / "stdout.log") + report = { + "status": "PASS", + "nominal_manifest_sha256": sha(read(attempt / "EVIDENCE_MANIFEST.json")), + "nominal_file_count": files, + "nominal_audit_stdout_matches_independent_replay": True, + "toolchain_import_count": len(imports), + "negative_manifest_sha256": sha(read(negative / "ARCHIVE_MANIFEST.json")), + "negative_file_count": neg_files, + "negative_cases": cases, + "failed_development_attempts_retained": 2, + "source_receipts": receipts, + "full_pytest_receipt_sha256": sha(read(full / "receipt.json")), + "full_pytest_stdout_sha256": full_receipt["stdout_sha256"], + "full_pytest_exit_code": full_receipt["exit_code"], + "full_pytest_reported": "329 passed, 202 subtests passed", + "full_pytest_inputs_explicitly_listed": len(full_receipt["inputs"]), + "cpython_refinement": "OPEN", + } + OUT.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + print( + json.dumps( + { + "status": "PASS", + "nominal_files": files, + "negative_cases": len(cases), + "source_receipts": len(receipts), + }, + sort_keys=True, + ) + ) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/formal/sonification/mat009/audit/archive_integrity.stderr b/formal/sonification/mat009/audit/archive_integrity.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/archive_integrity.stdout b/formal/sonification/mat009/audit/archive_integrity.stdout new file mode 100644 index 0000000..12bec53 --- /dev/null +++ b/formal/sonification/mat009/audit/archive_integrity.stdout @@ -0,0 +1 @@ +{"negative_cases": 6, "nominal_files": 23, "source_receipts": 4, "status": "PASS"} diff --git a/formal/sonification/mat009/audit/checker-replay-001.stderr b/formal/sonification/mat009/audit/checker-replay-001.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/checker-replay-001.stdout b/formal/sonification/mat009/audit/checker-replay-001.stdout new file mode 100644 index 0000000..3646156 --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001.stdout @@ -0,0 +1 @@ +{"error": null, "named_theorems": 22, "out": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/checker-replay-001", "status": "PASS"} diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-00-SplitModel.json b/formal/sonification/mat009/audit/checker-replay-001/build-00-SplitModel.json new file mode 100644 index 0000000..301c869 --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/build-00-SplitModel.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/mat009-lean-build-7u2zrhoc/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/checker-replay-001/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/checker-replay-001/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-01-DiagnosticFirstOwner.json b/formal/sonification/mat009/audit/checker-replay-001/build-01-DiagnosticFirstOwner.json new file mode 100644 index 0000000..0a6d1b1 --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/build-01-DiagnosticFirstOwner.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/mat009-lean-build-7u2zrhoc/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/checker-replay-001/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/checker-replay-001/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-02-TypedConsumer.json b/formal/sonification/mat009/audit/checker-replay-001/build-02-TypedConsumer.json new file mode 100644 index 0000000..f9c4c95 --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/build-02-TypedConsumer.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/mat009-lean-build-7u2zrhoc/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/checker-replay-001/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/checker-replay-001/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-03-ExactTypes.json b/formal/sonification/mat009/audit/checker-replay-001/build-03-ExactTypes.json new file mode 100644 index 0000000..a76153f --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/build-03-ExactTypes.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/mat009-lean-build-7u2zrhoc/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/checker-replay-001/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/checker-replay-001/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-04-LeanAudit.json b/formal/sonification/mat009/audit/checker-replay-001/build-04-LeanAudit.json new file mode 100644 index 0000000..4268fb0 --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/build-04-LeanAudit.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/mat009-lean-build-7u2zrhoc/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "21d9dcb639ded4b2c3047045038ff0d3a3c216f2c1f57554d0832fb81e7042cc", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/checker-replay-001/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/checker-replay-001/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/checker-replay-001/build-04-LeanAudit.stdout new file mode 100644 index 0000000..cbccb8f --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/build-04-LeanAudit.stdout @@ -0,0 +1,1664 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.initial","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._closed_1._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.initial._elambda_1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.initial.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_3","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_4","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRow","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._closed_1._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.lastRole [] x = none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_2._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.leakageReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.leakageReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.noParent","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.noParent x = False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.noParent.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout ∧\n s.campaigns MAT009.Role.train \"SAME\" ∧ s.campaigns MAT009.Role.holdout \"SAME\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.overwrite_retains_both_split_memberships","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason ∧ ¬(MAT009.finalize s).childReason MAT009.leakageReason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_can_supply_leakage_reason","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (reason : String), s.parent reason → (MAT009.finalize s).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_reason_survives_finalization","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.scan s [] = s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_append","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key ↔\n s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), s.crossed → (MAT009.scan s rows).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_crossed_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.scan s rows)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_familyLeakage_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key ↔ s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_owner_last","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason ↔ s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.Role → String → Prop) → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.splitIntersection","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (members : MAT009.Role → String → Prop),\n MAT009.splitIntersection members = ∃ key, members MAT009.Role.train key ∧ members MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.splitIntersection.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.step","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.step._elambda_1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key ∨ role = row.role ∧ key = row.campaign,\n labs := fun role key => s.labs role key ∨ role = row.role ∧ key = row.lab,\n crossed := s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role,\n parent := s.parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.step.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String × MAT009.Diagnostic.Owner)) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (x : String) (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_15._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_16._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_17._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_18._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_19._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_20._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_21._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_AUDIT declarations=351 theorems=95 diff --git a/formal/sonification/mat009/audit/checker-replay-001/declarations.json b/formal/sonification/mat009/audit/checker-replay-001/declarations.json new file mode 100644 index 0000000..8fd605c --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/declarations.json @@ -0,0 +1,3321 @@ +[ + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Consumer.parent_reason_blocks_any_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "TypedConsumer", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Consumer.shared_campaign_blocks_any_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "TypedConsumer", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = campaign) \u2192\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = campaign) \u2192\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.Owner", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.Registry", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (x : String), MAT009.Diagnostic.empty x = none", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.first_owner_not_last_writer", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 String \u2192 MAT009.Diagnostic.Owner \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 String \u2192 MAT009.Diagnostic.Owner \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : Option MAT009.Diagnostic.Owner \u2192 Sort u_1) \u2192\n (x : Option MAT009.Diagnostic.Owner) \u2192\n (Unit \u2192 motive none) \u2192 ((first : MAT009.Diagnostic.Owner) \u2192 motive (some first)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : Option MAT009.Diagnostic.Owner \u2192 Sort u_1) \u2192\n (x : Option MAT009.Diagnostic.Owner) \u2192\n (Unit \u2192 motive none) \u2192 ((first : MAT009.Diagnostic.Owner) \u2192 motive (some first)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_first_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first \u2192 MAT009.Diagnostic.register registry identity candidate identity = some first", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_new_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none \u2192 MAT009.Diagnostic.register registry identity candidate identity = some candidate", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_other_identity", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key \u2260 identity \u2192 MAT009.Diagnostic.register registry identity candidate key = registry key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_preserves_existing", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.register registry identity candidate key = some first", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n (Unit \u2192 motive []) \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n (Unit \u2192 motive []) \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.scan_first_owner_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (updates : List (String \u00d7 MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.scan registry updates key = some first", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n (t : MAT009.Final) \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.childReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.childReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason \u2227 f.crossed \u2228 reason = MAT009.leakageReason \u2227 f.leakage)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.crossed", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.hasReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.hasReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason \u2228 f.childReason reason)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.leakage", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 Prop \u2192 Prop \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 Prop \u2192 Prop \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } \u2192\n parent = parent_1 \u2227 crossed = crossed_1 \u2227 leakage = leakage_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Final.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 \u2227 crossed = crossed_1 \u2227 leakage = leakage_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.Final} \u2192 v1 = v2 \u2192 MAT009.Final.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.Final \u2192 MAT009.Final \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.parent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n (t : MAT009.Final) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n (t : MAT009.Final) \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final),\n f.status = if \u2203 reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status_blocked_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final), f.status = MAT009.Status.blocked \u2194 \u2203 reason, f.hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status_structural_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated \u2194 \u2200 (reason : String), \u00acf.hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Final.status_structural_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {p : \u03b1 \u2192 Prop}, (\u00ac\u2203 x, p x) = \u2200 (x : \u03b1), \u00acp x", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R1_initial", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none \u2227\n \u00ac(MAT009.initial parent).campaigns role campaign \u2227\n \u00ac(MAT009.initial parent).labs role lab \u2227\n \u00ac(MAT009.initial parent).crossed \u2227 ((MAT009.initial parent).parent reason \u2194 parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R2_assignment_overwrite", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role \u2227\n (\u2200 (key : String), key \u2260 row.campaign \u2192 (MAT009.step s row).owner key = s.owner key) \u2227\n (\u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key \u2194 s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign) \u2227\n \u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key \u2194 s.labs role key \u2228 role = row.role \u2227 key = row.lab", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R3_cross_role_trigger", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed \u2194 s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R4_stickiness", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign \u2192 (MAT009.step s row).campaigns role campaign) \u2227\n (s.labs role lab \u2192 (MAT009.step s row).labs role lab) \u2227\n (s.crossed \u2192 (MAT009.step s row).crossed) \u2227\n (MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)) \u2227\n ((MAT009.step s row).parent reason \u2194 s.parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R5_final_set_intersection", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason \u2194\n (\u2203 key, s.campaigns MAT009.Role.train key \u2227 s.campaigns MAT009.Role.holdout key) \u2228\n \u2203 key, s.labs MAT009.Role.train key \u2227 s.labs MAT009.Role.holdout key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R5_parent_union", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason \u2194 s.parent MAT009.leakageReason \u2228 MAT009.familyLeakage s", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign \u2194\n \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = campaign) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab \u2194 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = lab) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).parent reason \u2194 parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_cross_trigger_in_finite_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (\u2203 previous, (MAT009.scan s before).owner row.campaign = some previous \u2227 previous \u2260 row.role) \u2192\n (MAT009.scan s (before ++ row :: after)).crossed", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason \u2194\n (\u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = key) \u2228\n \u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.lab = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.lab = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_latest_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R6_parent_reason_survives", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_accepted_example", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_nonvacuous", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(\u2203 rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) \u2227\n \u2203 rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_rejected_example", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.ReasonSet", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 (t : MAT009.Role) \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.holdout", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.holdout.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Role.holdout = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Role} \u2192 x = y \u2192 MAT009.Role.noConfusionType P x y", + "unsafe_definition": false + }, + { + "axioms": [ + "lcUnreachable" + ], + "declaration": "MAT009.Role.noConfusion._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Role} \u2192 x = y \u2192 MAT009.Role.noConfusionType P x y", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 _neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._lambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort v\u271d \u2192 MAT009.Role \u2192 MAT009.Role \u2192 Sort v\u271d", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat_toCtorIdx", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 (t : MAT009.Role) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 (t : MAT009.Role) \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.train", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.train.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Role.train = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.campaign", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n (t : MAT009.Row) \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.lab", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String \u2192 String \u2192 MAT009.Role \u2192 MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String \u2192 String \u2192 MAT009.Role \u2192 MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } \u2192\n campaign = campaign_1 \u2227 lab = lab_1 \u2227 role = role_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Row.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 \u2227 lab = lab_1 \u2227 role = role_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.Row} \u2192 v1 = v2 \u2192 MAT009.Row.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.Row \u2192 MAT009.Row \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n (t : MAT009.Row) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n (t : MAT009.Row) \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.role", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.campaigns", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Role \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n (t : MAT009.State) \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.crossed", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.labs", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Role \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(String \u2192 Option MAT009.Role) \u2192\n (MAT009.Role \u2192 String \u2192 Prop) \u2192 (MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop \u2192 MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(String \u2192 Option MAT009.Role) \u2192\n (MAT009.Role \u2192 String \u2192 Prop) \u2192 (MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop \u2192 MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {owner : String \u2192 Option MAT009.Role} {campaigns labs : MAT009.Role \u2192 String \u2192 Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String \u2192 Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role \u2192 String \u2192 Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } \u2192\n owner = owner_1 \u2227 campaigns = campaigns_1 \u2227 labs = labs_1 \u2227 crossed = crossed_1 \u2227 parent = parent_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.State.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (owner : String \u2192 Option MAT009.Role) (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String \u2192 Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role \u2192 String \u2192 Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 \u2227 campaigns = campaigns_1 \u2227 labs = labs_1 \u2227 crossed = crossed_1 \u2227 parent = parent_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (owner : String \u2192 Option MAT009.Role) (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.State} \u2192 v1 = v2 \u2192 MAT009.State.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.State \u2192 MAT009.State \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.owner", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.parent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n (t : MAT009.State) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n (t : MAT009.State) \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.blocked", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.blocked.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Status.blocked = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n (t : MAT009.Status) \u2192 motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Status} \u2192 x = y \u2192 MAT009.Status.noConfusionType P x y", + "unsafe_definition": false + }, + { + "axioms": [ + "lcUnreachable" + ], + "declaration": "MAT009.Status.noConfusion._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Status} \u2192 x = y \u2192 MAT009.Status.noConfusionType P x y", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 _neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort v\u271d \u2192 MAT009.Status \u2192 MAT009.Status \u2192 Sort v\u271d", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat_toCtorIdx", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 (t : MAT009.Status) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n (t : MAT009.Status) \u2192 motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.structuralOnlyUnauthenticated", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns \u2228 MAT009.splitIntersection s.labs)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage_step_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.finalize", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.finalize._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Final", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.finalize._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.finalize.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.initial", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._elambda_1", + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.initial._elambda_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.initial._elambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.initial.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [ + "lcProof" + ], + "declaration": "MAT009.instDecidableEqRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._proof_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx \u2192 x = y", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._proof_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Role), \u00acx.toCtorIdx = y.toCtorIdx \u2192 x = y \u2192 False", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [ + "lcProof" + ], + "declaration": "MAT009.instDecidableEqStatus._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._proof_3", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx \u2192 x = y", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._proof_4", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Status), \u00acx.toCtorIdx = y.toCtorIdx \u2192 x = y \u2192 False", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String), MAT009.lastRole [] x = none", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : Option MAT009.Role \u2192 Sort u_1) \u2192\n (x : Option MAT009.Role) \u2192 ((role : MAT009.Role) \u2192 motive (some role)) \u2192 (Unit \u2192 motive none) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : Option MAT009.Role \u2192 Sort u_1) \u2192\n (x : Option MAT009.Role) \u2192 ((role : MAT009.Role) \u2192 motive (some role)) \u2192 (Unit \u2192 motive none) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_2", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_2._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.noParent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.noParent._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.ReasonSet", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.noParent._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.noParent.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String), MAT009.noParent x = False", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.overwrite_retains_both_split_memberships", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout \u2227\n s.campaigns MAT009.Role.train \"SAME\" \u2227 s.campaigns MAT009.Role.holdout \"SAME\"", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.parent_can_supply_leakage_reason", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason \u2227 \u00ac(MAT009.finalize s).childReason MAT009.leakageReason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.parent_reason_survives_finalization", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (reason : String), s.parent reason \u2192 (MAT009.finalize s).hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.scan._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.scan._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State), MAT009.scan s [] = s", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (Unit \u2192 motive []) \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (Unit \u2192 motive []) \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.scan_append", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key \u2194\n s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {a b : \u03b1}, (a = b) = (b = a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, ((a \u2228 b) \u2228 c) = (a \u2228 b \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, (a \u2228 b \u2228 c) = (b \u2228 a \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_8", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b : Prop}, (a \u2228 b) = (b \u2228 a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_crossed_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row), s.crossed \u2192 (MAT009.scan s rows).crossed", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_familyLeakage_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.scan s rows)", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.scan_labs_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key \u2194 s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {a b : \u03b1}, (a = b) = (b = a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, ((a \u2228 b) \u2228 c) = (a \u2228 b \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, (a \u2228 b \u2228 c) = (b \u2228 a \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_8", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b : Prop}, (a \u2228 b) = (b \u2228 a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_owner_last", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan_parent", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason \u2194 s.parent reason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.splitIntersection", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.splitIntersection.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (members : MAT009.Role \u2192 String \u2192 Prop),\n MAT009.splitIntersection members = \u2203 key, members MAT009.Role.train key \u2227 members MAT009.Role.holdout key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.step", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._elambda_1", + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.step._elambda_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.step._elambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.step.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign,\n labs := fun role key => s.labs role key \u2228 role = row.role \u2227 key = row.lab,\n crossed := s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role,\n parent := s.parent }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) (h_1 : Unit \u2192 motive [])\n (h_2 :\n (identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) (h_1 : Unit \u2192 motive [])\n (h_2 :\n (identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n motive [] \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n motive [] \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 String \u2192 Sort u_1) (x : String) (h_1 : (x : String) \u2192 motive [] x)\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 String \u2192 Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) \u2192 motive [] x)\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : MAT009.Role \u2192 Sort u_1) \u2192\n (x : MAT009.Role) \u2192 (Unit \u2192 motive MAT009.Role.train) \u2192 (Unit \u2192 motive MAT009.Role.holdout) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.match_1.\u00ab_@\u00bb.SplitModel._hyg.109._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : MAT009.Role \u2192 Sort u_1) \u2192\n (x : MAT009.Role) \u2192 (Unit \u2192 motive MAT009.Role.train) \u2192 (Unit \u2192 motive MAT009.Role.holdout) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_13._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_14._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_13._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_14._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_15._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_16._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_17._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_18._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_19._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_20._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_21._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : MAT009.Status \u2192 Sort u_1) \u2192\n (x : MAT009.Status) \u2192\n (Unit \u2192 motive MAT009.Status.blocked) \u2192 (Unit \u2192 motive MAT009.Status.structuralOnlyUnauthenticated) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.match_1.\u00ab_@\u00bb.SplitModel._hyg.882._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : MAT009.Status \u2192 Sort u_1) \u2192\n (x : MAT009.Status) \u2192\n (Unit \u2192 motive MAT009.Status.blocked) \u2192 (Unit \u2192 motive MAT009.Status.structuralOnlyUnauthenticated) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 Sort u_1) (h_1 : Unit \u2192 motive [])\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit \u2192 motive [])\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192 motive [] \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192 motive [] \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + } +] diff --git a/formal/sonification/mat009/audit/checker-replay-001/lean-version.json b/formal/sonification/mat009/audit/checker-replay-001/lean-version.json new file mode 100644 index 0000000..10f4b46 --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/lean-version.json @@ -0,0 +1,12 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--version" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b", + "timed_out": false, + "timeout_seconds": 30 +} diff --git a/formal/sonification/mat009/audit/checker-replay-001/lean-version.stderr b/formal/sonification/mat009/audit/checker-replay-001/lean-version.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/checker-replay-001/lean-version.stdout b/formal/sonification/mat009/audit/checker-replay-001/lean-version.stdout new file mode 100644 index 0000000..507e58d --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/lean-version.stdout @@ -0,0 +1 @@ +Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release) diff --git a/formal/sonification/mat009/audit/checker-replay-001/named-axioms.json b/formal/sonification/mat009/audit/checker-replay-001/named-axioms.json new file mode 100644 index 0000000..41676d1 --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/named-axioms.json @@ -0,0 +1,62 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Consumer.shared_campaign_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Diagnostic.first_owner_not_last_writer": [ + "propext" + ], + "MAT009.Diagnostic.scan_first_owner_sticky": [ + "propext" + ], + "MAT009.M009_R1_initial": [ + "propext" + ], + "MAT009.M009_R2_assignment_overwrite": [ + "propext" + ], + "MAT009.M009_R3_cross_role_trigger": [], + "MAT009.M009_R4_stickiness": [], + "MAT009.M009_R5_final_set_intersection": [ + "propext" + ], + "MAT009.M009_R5_parent_union": [ + "propext" + ], + "MAT009.M009_R6_arbitrary_finite_scan": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_cross_trigger_in_finite_scan": [ + "propext" + ], + "MAT009.M009_R6_final_leakage_iff": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_latest_owner": [ + "propext" + ], + "MAT009.M009_R6_parent_reason_survives": [], + "MAT009.M009_R7_accepted_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_nonvacuous": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_rejected_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ] +} diff --git a/formal/sonification/mat009/audit/checker-replay-001/result.json b/formal/sonification/mat009/audit/checker-replay-001/result.json new file mode 100644 index 0000000..e4d8dd1 --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/result.json @@ -0,0 +1,55 @@ +{ + "AUDIT_ACCEPTED": "OPEN", + "DIFFERENTIAL_TESTED": "NOT_EXECUTED", + "MODEL_PROVED": "PASS_FOR_SCOPED_MATHEMATICAL_MODEL", + "REFINEMENT_PROVED": "OPEN", + "baseline_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "compiler_auxiliary_count": 146, + "completed_utc": "2026-11-10T01:11:04.004499+00:00", + "declaration_count": 351, + "external_import_count": 1303, + "input_sha256": { + "DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "LeanAudit.lean": "7aeabffbd65357e4ea41d773950bc7b52c892c5347b259f51d6a3831296aced8", + "PROOF_NOTES.md": "660493388f779bd1fc38a30a8051596e05985250e08b5f51e5c226da7e354cbf", + "SplitModel.lean": "2d6f80e9749e846db5f7c54bcc189c1ae3f345e19677842c002c2bea69790795", + "TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa", + "check.py": "125041442f582e7fc254dc341926b4cfb935ac964057c930021366a950a5a108", + "lean-toolchain": "55e97be96000b5e9e290c9e74482e5e317861499a5540353ce845471bded8cea" + }, + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "lean_version": "Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release)", + "logical_axioms": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "named_intended_theorems": [ + "MAT009.Consumer.parent_reason_blocks_any_scan", + "MAT009.Consumer.shared_campaign_blocks_any_scan", + "MAT009.Diagnostic.first_owner_not_last_writer", + "MAT009.Diagnostic.register_first_owner", + "MAT009.Diagnostic.register_new_owner", + "MAT009.Diagnostic.register_other_identity", + "MAT009.Diagnostic.register_preserves_existing", + "MAT009.Diagnostic.scan_first_owner_sticky", + "MAT009.M009_R1_initial", + "MAT009.M009_R2_assignment_overwrite", + "MAT009.M009_R3_cross_role_trigger", + "MAT009.M009_R4_stickiness", + "MAT009.M009_R5_final_set_intersection", + "MAT009.M009_R5_parent_union", + "MAT009.M009_R6_arbitrary_finite_scan", + "MAT009.M009_R6_cross_trigger_in_finite_scan", + "MAT009.M009_R6_final_leakage_iff", + "MAT009.M009_R6_latest_owner", + "MAT009.M009_R6_parent_reason_survives", + "MAT009.M009_R7_accepted_example", + "MAT009.M009_R7_nonvacuous", + "MAT009.M009_R7_rejected_example" + ], + "started_utc": "2026-11-10T01:10:43.973217+00:00", + "status": "PASS", + "theorem_declaration_count_including_generated": 95 +} diff --git a/formal/sonification/mat009/audit/checker-replay-001/theorem-types.json b/formal/sonification/mat009/audit/checker-replay-001/theorem-types.json new file mode 100644 index 0000000..1eb358e --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/theorem-types.json @@ -0,0 +1,24 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "MAT009.Consumer.shared_campaign_blocks_any_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = campaign) \u2192\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = campaign) \u2192\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "MAT009.Diagnostic.first_owner_not_last_writer": "MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")", + "MAT009.Diagnostic.register_first_owner": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first \u2192 MAT009.Diagnostic.register registry identity candidate identity = some first", + "MAT009.Diagnostic.register_new_owner": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none \u2192 MAT009.Diagnostic.register registry identity candidate identity = some candidate", + "MAT009.Diagnostic.register_other_identity": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key \u2260 identity \u2192 MAT009.Diagnostic.register registry identity candidate key = registry key", + "MAT009.Diagnostic.register_preserves_existing": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.register registry identity candidate key = some first", + "MAT009.Diagnostic.scan_first_owner_sticky": "\u2200 (registry : MAT009.Diagnostic.Registry) (updates : List (String \u00d7 MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.scan registry updates key = some first", + "MAT009.M009_R1_initial": "\u2200 (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none \u2227\n \u00ac(MAT009.initial parent).campaigns role campaign \u2227\n \u00ac(MAT009.initial parent).labs role lab \u2227\n \u00ac(MAT009.initial parent).crossed \u2227 ((MAT009.initial parent).parent reason \u2194 parent reason)", + "MAT009.M009_R2_assignment_overwrite": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role \u2227\n (\u2200 (key : String), key \u2260 row.campaign \u2192 (MAT009.step s row).owner key = s.owner key) \u2227\n (\u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key \u2194 s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign) \u2227\n \u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key \u2194 s.labs role key \u2228 role = row.role \u2227 key = row.lab", + "MAT009.M009_R3_cross_role_trigger": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed \u2194 s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role", + "MAT009.M009_R4_stickiness": "\u2200 (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign \u2192 (MAT009.step s row).campaigns role campaign) \u2227\n (s.labs role lab \u2192 (MAT009.step s row).labs role lab) \u2227\n (s.crossed \u2192 (MAT009.step s row).crossed) \u2227\n (MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)) \u2227\n ((MAT009.step s row).parent reason \u2194 s.parent reason)", + "MAT009.M009_R5_final_set_intersection": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason \u2194\n (\u2203 key, s.campaigns MAT009.Role.train key \u2227 s.campaigns MAT009.Role.holdout key) \u2228\n \u2203 key, s.labs MAT009.Role.train key \u2227 s.labs MAT009.Role.holdout key", + "MAT009.M009_R5_parent_union": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason \u2194 s.parent MAT009.leakageReason \u2228 MAT009.familyLeakage s", + "MAT009.M009_R6_arbitrary_finite_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign \u2194\n \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = campaign) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab \u2194 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = lab) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).parent reason \u2194 parent reason)", + "MAT009.M009_R6_cross_trigger_in_finite_scan": "\u2200 (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (\u2203 previous, (MAT009.scan s before).owner row.campaign = some previous \u2227 previous \u2260 row.role) \u2192\n (MAT009.scan s (before ++ row :: after)).crossed", + "MAT009.M009_R6_final_leakage_iff": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason \u2194\n (\u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = key) \u2228\n \u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.lab = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.lab = key", + "MAT009.M009_R6_latest_owner": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign", + "MAT009.M009_R6_parent_reason_survives": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason", + "MAT009.M009_R7_accepted_example": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated", + "MAT009.M009_R7_nonvacuous": "(\u2203 rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) \u2227\n \u2203 rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked", + "MAT009.M009_R7_rejected_example": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked" +} diff --git a/formal/sonification/mat009/audit/checker-replay-001/toolchain-imports.json b/formal/sonification/mat009/audit/checker-replay-001/toolchain-imports.json new file mode 100644 index 0000000..e56b85e --- /dev/null +++ b/formal/sonification/mat009/audit/checker-replay-001/toolchain-imports.json @@ -0,0 +1,5214 @@ +{ + "Init": { + "relative_path": "lib/lean/Init.olean", + "sha256": "f14f6c9ea0d9eb2a6fe7bdad84a6610657db3d006805708c1a62ac72b676e944" + }, + "Init.BinderNameHint": { + "relative_path": "lib/lean/Init/BinderNameHint.olean", + "sha256": "87ad3f24763ab6293e9907bd53fd2c87397a1bcc41741d496530391424f397f0" + }, + "Init.BinderPredicates": { + "relative_path": "lib/lean/Init/BinderPredicates.olean", + "sha256": "b87d6204d662e2164c4ccac16ffe6ef34c17e46473219f7615a8e5a902f88399" + }, + "Init.ByCases": { + "relative_path": "lib/lean/Init/ByCases.olean", + "sha256": "a446cd54c7d9b5cd764bac51e0e86bdbfd92cceb559a0ce174c8bfdd0880031f" + }, + "Init.Classical": { + "relative_path": "lib/lean/Init/Classical.olean", + "sha256": "146557a1d2b3d89dccc8a37db0eaf2ca41b7e8b7e9699cc1d2040209ab2d5206" + }, + "Init.Coe": { + "relative_path": "lib/lean/Init/Coe.olean", + "sha256": "8264daae9323339b7a0e4648e9054bc4d6bfa2ed2efe3bbf60f3ed4c85ededf1" + }, + "Init.Control": { + "relative_path": "lib/lean/Init/Control.olean", + "sha256": "02b03cb26d015878cb086d2aa9619d028653c4d7b13f7d27defa18c526f59acf" + }, + "Init.Control.Basic": { + "relative_path": "lib/lean/Init/Control/Basic.olean", + "sha256": "770f96586bd33c585cba7ae023b9ba455fdbcc6656008a7ae44921a2a381e673" + }, + "Init.Control.EState": { + "relative_path": "lib/lean/Init/Control/EState.olean", + "sha256": "bf304f9ebac42bc1e0604ed85fd34ccfbfb1d48c36a0378264daa004c7b1663a" + }, + "Init.Control.Except": { + "relative_path": "lib/lean/Init/Control/Except.olean", + "sha256": "2df44aacfe3c18de279a500ce89ca07fdaae3ac41ee5e13753f675ffcee590bf" + }, + "Init.Control.ExceptCps": { + "relative_path": "lib/lean/Init/Control/ExceptCps.olean", + "sha256": "abf85a131ec12cc4943351cd8e94d25a8ea643d8aed05e3174ddf102a92c82ab" + }, + "Init.Control.Id": { + "relative_path": "lib/lean/Init/Control/Id.olean", + "sha256": "3bdbaf6aab9ebd5bc7f69df7ea3817d60fe3e93621ceac45998aeada2ab0f2fb" + }, + "Init.Control.Lawful": { + "relative_path": "lib/lean/Init/Control/Lawful.olean", + "sha256": "d0e4de63caa049aa63032c262df55cb6e05decd6a639b3197d03a94bfb9cf630" + }, + "Init.Control.Lawful.Basic": { + "relative_path": "lib/lean/Init/Control/Lawful/Basic.olean", + "sha256": "2e5796aeb855144054fe96c87df8c1942fe57363ca46616dd713602e9e83008e" + }, + "Init.Control.Lawful.Instances": { + "relative_path": "lib/lean/Init/Control/Lawful/Instances.olean", + "sha256": "3a42743efc08488094315361697052bbea44791dc9b26bb42a7687be82351798" + }, + "Init.Control.Lawful.Lemmas": { + "relative_path": "lib/lean/Init/Control/Lawful/Lemmas.olean", + "sha256": "872c79b884079a180f2cb4efe5d5ccfd86e8231040ccf0286fdc0ae3e48de6cb" + }, + "Init.Control.Option": { + "relative_path": "lib/lean/Init/Control/Option.olean", + "sha256": "2fd4fd3d76c35d38f22bbd43287b2034db3fc09e9db40a72d64766fc2e1a27cf" + }, + "Init.Control.Reader": { + "relative_path": "lib/lean/Init/Control/Reader.olean", + "sha256": "0ee81ccf6c24215ac02fbddbc47f9d0ec88154c747938db879dc176e84cab35c" + }, + "Init.Control.State": { + "relative_path": "lib/lean/Init/Control/State.olean", + "sha256": "9967249936b6e2882f7c6551ed25b8c11c499e5146884f43c851019a9212b58e" + }, + "Init.Control.StateCps": { + "relative_path": "lib/lean/Init/Control/StateCps.olean", + "sha256": "a7e465f72965884c566492bf128ce366f9b6259feb3ff78a2dc7941276668910" + }, + "Init.Control.StateRef": { + "relative_path": "lib/lean/Init/Control/StateRef.olean", + "sha256": "4c48d97631e2c887a9109f0a3b11930e960674722db2d7ec96228ebb4cebc397" + }, + "Init.Conv": { + "relative_path": "lib/lean/Init/Conv.olean", + "sha256": "27e368664cd48cc7db0b6d8b936fcf3bd3b0c8652d67c7d72ed1a70e481c2cae" + }, + "Init.Core": { + "relative_path": "lib/lean/Init/Core.olean", + "sha256": "325d3e1934d1e99dbf7bde7643d6b1a582e0e98a2bc67156ecbfb1e044c81b62" + }, + "Init.Data": { + "relative_path": "lib/lean/Init/Data.olean", + "sha256": "e0fb356d8ff226c74733d563a2fddfd5d3f9031353f07eab9316189729ea0b05" + }, + "Init.Data.AC": { + "relative_path": "lib/lean/Init/Data/AC.olean", + "sha256": "c31d122ca9a36ebccfade139b5d01a27520cfe5da9c13fbcee0de6afc18e6e2e" + }, + "Init.Data.Array": { + "relative_path": "lib/lean/Init/Data/Array.olean", + "sha256": "628b1fe1e5028d01279c0e4b94f8a75a5404c5c2c62f56cb0f2f93e949b871fe" + }, + "Init.Data.Array.Attach": { + "relative_path": "lib/lean/Init/Data/Array/Attach.olean", + "sha256": "17dd10a433d8c5eefec2380008930b9db90cf5baaf6a111862d248280489809b" + }, + "Init.Data.Array.Basic": { + "relative_path": "lib/lean/Init/Data/Array/Basic.olean", + "sha256": "c1b3ecb3200b55fd9c0f508d6a70518cad1e6cd68e3333d6363ac275efa290b4" + }, + "Init.Data.Array.BasicAux": { + "relative_path": "lib/lean/Init/Data/Array/BasicAux.olean", + "sha256": "498f1b5994a45cd4303c9a5a1252d20f1706d7227fd6068a54a21102c4ecb49d" + }, + "Init.Data.Array.BinSearch": { + "relative_path": "lib/lean/Init/Data/Array/BinSearch.olean", + "sha256": "c8ffd80ccccd8119ba40ef890a3408310abd6535ecb282e8ecd8f8b943dad63a" + }, + "Init.Data.Array.Bootstrap": { + "relative_path": "lib/lean/Init/Data/Array/Bootstrap.olean", + "sha256": "d22a9ec6e5a01f844321cfd7ecfba9f02f0d15cffd6e7667315e36caaf2f4d5d" + }, + "Init.Data.Array.Count": { + "relative_path": "lib/lean/Init/Data/Array/Count.olean", + "sha256": "5cac2d9caf60f31946dcc2b3ecacde3f52d6c143dd91504af2245e9203360700" + }, + "Init.Data.Array.DecidableEq": { + "relative_path": "lib/lean/Init/Data/Array/DecidableEq.olean", + "sha256": "61699c7b47f0fe3ceabab22f86fad529d0c53c229168e2eb5a4c81b3b44161da" + }, + "Init.Data.Array.Erase": { + "relative_path": "lib/lean/Init/Data/Array/Erase.olean", + "sha256": "a39e0a7704569c26626a57596aa4838b835eb5940a90874febcd53aed46c3676" + }, + "Init.Data.Array.Extract": { + "relative_path": "lib/lean/Init/Data/Array/Extract.olean", + "sha256": "d3ae74a38b69aaf4e3f7cf247e3b51d97845035076f21c37f9516f17dec53115" + }, + "Init.Data.Array.FinRange": { + "relative_path": "lib/lean/Init/Data/Array/FinRange.olean", + "sha256": "ccdba2d4e97ed32f04ea6d66ffa24cd4667d3c17e923939d251b12b8c156ff0a" + }, + "Init.Data.Array.Find": { + "relative_path": "lib/lean/Init/Data/Array/Find.olean", + "sha256": "60374792eaf3e1c935911342aadc2e0fe2c2df226d1b2ffeead456d396242565" + }, + "Init.Data.Array.GetLit": { + "relative_path": "lib/lean/Init/Data/Array/GetLit.olean", + "sha256": "7500dfd2f61932caa3bb61dff522cea1d043f9d52f875df9ca9377cb5be6ae00" + }, + "Init.Data.Array.InsertIdx": { + "relative_path": "lib/lean/Init/Data/Array/InsertIdx.olean", + "sha256": "0885128103fece2609d3de7d95170ead99c2422e3b2611efc17ad64d13c54b93" + }, + "Init.Data.Array.InsertionSort": { + "relative_path": "lib/lean/Init/Data/Array/InsertionSort.olean", + "sha256": "00eeffee6c9c944e626b54aa1ba80e2817ee0d6d72a58b4504ed5d6150963199" + }, + "Init.Data.Array.Lemmas": { + "relative_path": "lib/lean/Init/Data/Array/Lemmas.olean", + "sha256": "6d70a718a88e0f5e3a2fbf58ab9a927086ecb80cc131ca4daf61b8373b29bc7e" + }, + "Init.Data.Array.Lex": { + "relative_path": "lib/lean/Init/Data/Array/Lex.olean", + "sha256": "dcfcf549b75b61784fc2761dd6ab27112a5f3f85635156ff45f17907241f873c" + }, + "Init.Data.Array.Lex.Basic": { + "relative_path": "lib/lean/Init/Data/Array/Lex/Basic.olean", + "sha256": "5099ffc811762f879efd0a8d2dc6a6f46b03aaf13e5d7198a40b028f84339f6a" + }, + "Init.Data.Array.Lex.Lemmas": { + "relative_path": "lib/lean/Init/Data/Array/Lex/Lemmas.olean", + "sha256": "edd3b29355f8877ba1d4baa7eb7191d19ec56b68e8caf7136e56562d46f2cf00" + }, + "Init.Data.Array.MapIdx": { + "relative_path": "lib/lean/Init/Data/Array/MapIdx.olean", + "sha256": "fa5fa7562d940a373cde8271701c1b1b6aa4ccc7685a7d8aee563bd6a531b023" + }, + "Init.Data.Array.Mem": { + "relative_path": "lib/lean/Init/Data/Array/Mem.olean", + "sha256": "6d8b81e87c3f6194010d50453930aef26a33d02836f577fdf528f96427fd2871" + }, + "Init.Data.Array.Monadic": { + "relative_path": "lib/lean/Init/Data/Array/Monadic.olean", + "sha256": "4c7ac2031c6b67e8904e378eab4f4e4e52a741464f759346c6bbadf358353040" + }, + "Init.Data.Array.OfFn": { + "relative_path": "lib/lean/Init/Data/Array/OfFn.olean", + "sha256": "269214e9ef1869f764ea7744d27f9bb5f2d88c06a199c35a523bcab485056514" + }, + "Init.Data.Array.Perm": { + "relative_path": "lib/lean/Init/Data/Array/Perm.olean", + "sha256": "df04ccb43fffbdfc14af5e01b9a288eba07cf33dfd934fefc7d3ee62380abbad" + }, + "Init.Data.Array.QSort": { + "relative_path": "lib/lean/Init/Data/Array/QSort.olean", + "sha256": "182e2fb5ccae0e4290f1df223f6da4fe8e4671735b1f8be5768f67aecd976a9b" + }, + "Init.Data.Array.Range": { + "relative_path": "lib/lean/Init/Data/Array/Range.olean", + "sha256": "470d0a04ec3f6acf4e1a4a17c0ac006ff4f4ca6a132e6fe75cb24a3422045edf" + }, + "Init.Data.Array.Set": { + "relative_path": "lib/lean/Init/Data/Array/Set.olean", + "sha256": "47765fffb2b0ff3eeb3b9fcdf1f872a1264fbecc6fd9fa3b3bcacb14305d21cc" + }, + "Init.Data.Array.Subarray": { + "relative_path": "lib/lean/Init/Data/Array/Subarray.olean", + "sha256": "a2b4eb8e9ff8708540ec1224bc150ec997f6b339fc526c8f905824dab5814eb1" + }, + "Init.Data.Array.Subarray.Split": { + "relative_path": "lib/lean/Init/Data/Array/Subarray/Split.olean", + "sha256": "e70f52b7a240f6f48ece84e6e5efe81be6f0aa59787d93877069acf4d299d6da" + }, + "Init.Data.Array.TakeDrop": { + "relative_path": "lib/lean/Init/Data/Array/TakeDrop.olean", + "sha256": "cb756a88720cd6633a931cc4cd278804391f1d4b6e7804fed40e0014f27250e4" + }, + "Init.Data.Array.Zip": { + "relative_path": "lib/lean/Init/Data/Array/Zip.olean", + "sha256": "57b72c19de8fc1a600d24da0a2ce3edc78620fc487668928f5092c62e6199bf8" + }, + "Init.Data.BEq": { + "relative_path": "lib/lean/Init/Data/BEq.olean", + "sha256": "fc264bbc09afcdee4cf301170287f97dce8426a1102c2c20a2b3324af470be03" + }, + "Init.Data.Basic": { + "relative_path": "lib/lean/Init/Data/Basic.olean", + "sha256": "320b6a318c7f47b88b4cc52a3dd10f1c253c4ba15882c0fba4d0b6cc8b258629" + }, + "Init.Data.BitVec": { + "relative_path": "lib/lean/Init/Data/BitVec.olean", + "sha256": "9806987569400445640812d3675deb3d56b79c12d42e8168aebba2d2d42ef3cd" + }, + "Init.Data.BitVec.Basic": { + "relative_path": "lib/lean/Init/Data/BitVec/Basic.olean", + "sha256": "263c59d8eecd1dca7acf46649c80ce9d7b5680064309b9eedc76d4ca02a03e34" + }, + "Init.Data.BitVec.BasicAux": { + "relative_path": "lib/lean/Init/Data/BitVec/BasicAux.olean", + "sha256": "1ba7804f2a9d1739a51b1e7dea3821a38743373b1072bf85c41d247cfa8bcbaa" + }, + "Init.Data.BitVec.Bitblast": { + "relative_path": "lib/lean/Init/Data/BitVec/Bitblast.olean", + "sha256": "c7663248b6910786438135f4eabd9f5fce7ddb61628c667345d04c4be6dda7b3" + }, + "Init.Data.BitVec.Folds": { + "relative_path": "lib/lean/Init/Data/BitVec/Folds.olean", + "sha256": "b4d4aa0cfd3f346fd1f6361552afcf5245668c55fd2d0ad1ebf467f841ae20d0" + }, + "Init.Data.BitVec.Lemmas": { + "relative_path": "lib/lean/Init/Data/BitVec/Lemmas.olean", + "sha256": "c11aebc16adf6f6fdd8d3a9dcb74b295034999579793c2f4eb79b044fccd618e" + }, + "Init.Data.Bool": { + "relative_path": "lib/lean/Init/Data/Bool.olean", + "sha256": "24c3fa2ac49e5f1681100130790a5f322bed745e47b503e25ff49b7a3c5f6d68" + }, + "Init.Data.ByteArray": { + "relative_path": "lib/lean/Init/Data/ByteArray.olean", + "sha256": "3c0fa93b6b78ea8b3733b02a83dca06a085b3938355811eee6c06cbdd0179a8e" + }, + "Init.Data.ByteArray.Basic": { + "relative_path": "lib/lean/Init/Data/ByteArray/Basic.olean", + "sha256": "f995de7efe27dc6573bf9cf32e2399ba4ee0659f0b64f07285bb15edbd8048fd" + }, + "Init.Data.Cast": { + "relative_path": "lib/lean/Init/Data/Cast.olean", + "sha256": "3413b2ca8a0098a6e572d7728ed1532eaa21ca10067197f3b214aeff2ccdd651" + }, + "Init.Data.Channel": { + "relative_path": "lib/lean/Init/Data/Channel.olean", + "sha256": "945114f1dd771f97d93cdac7466ff0ff1e0f1461bc4fda27b5f5b9715dcdc174" + }, + "Init.Data.Char": { + "relative_path": "lib/lean/Init/Data/Char.olean", + "sha256": "818aac23581c282c3f6d2f80775ac47ce6d31b55ce54b3d187b6ed4b8de8cc63" + }, + "Init.Data.Char.Basic": { + "relative_path": "lib/lean/Init/Data/Char/Basic.olean", + "sha256": "6ed0988e9f8e134dbc30d38ed257a44850e98d71b7d77d5a977f4297e085a0f1" + }, + "Init.Data.Char.Lemmas": { + "relative_path": "lib/lean/Init/Data/Char/Lemmas.olean", + "sha256": "030a6cdcb16360b9f90d072e40bd66ce8aafab43137dd9d03e82229ebec3ced9" + }, + "Init.Data.Fin": { + "relative_path": "lib/lean/Init/Data/Fin.olean", + "sha256": "e955ad0ee4c253aaf23086b1452740c2c9888c594b9c404bb34699868773dfe2" + }, + "Init.Data.Fin.Basic": { + "relative_path": "lib/lean/Init/Data/Fin/Basic.olean", + "sha256": "e4b2abb6d8a424da6e7ff21b0e71ead051c0605e76db3680888305ac128f5b55" + }, + "Init.Data.Fin.Bitwise": { + "relative_path": "lib/lean/Init/Data/Fin/Bitwise.olean", + "sha256": "e80029b17e55e5e4b917ef076545aa017bb7844bed24f7f3c376952d82f3e21b" + }, + "Init.Data.Fin.Fold": { + "relative_path": "lib/lean/Init/Data/Fin/Fold.olean", + "sha256": "8d618def1ed982a59898c72e714939d861836ea9f84fe4414677c4b7fac9295a" + }, + "Init.Data.Fin.Iterate": { + "relative_path": "lib/lean/Init/Data/Fin/Iterate.olean", + "sha256": "f6553fbf009244d2b848079f104ef424f9048ad5e5e45276169f58b674dbdf58" + }, + "Init.Data.Fin.Lemmas": { + "relative_path": "lib/lean/Init/Data/Fin/Lemmas.olean", + "sha256": "9fe597ce2f3edce6a67a4542d72bd0300cc643a484297fc8d61966a28b61935d" + }, + "Init.Data.Fin.Log2": { + "relative_path": "lib/lean/Init/Data/Fin/Log2.olean", + "sha256": "d4e9f3e05222a066c5fdc327065d7147d16a939ebcedf988b8e428bfd7a1d6a3" + }, + "Init.Data.Float": { + "relative_path": "lib/lean/Init/Data/Float.olean", + "sha256": "92478058b9b83eddef7ecea3797414d74db6e61e2b688e64ab7ba81df127b15a" + }, + "Init.Data.Float32": { + "relative_path": "lib/lean/Init/Data/Float32.olean", + "sha256": "2a37e1add33b9d6047350feaa9d87b913f1e58718bd5a3cb597d60e6573f9212" + }, + "Init.Data.FloatArray": { + "relative_path": "lib/lean/Init/Data/FloatArray.olean", + "sha256": "78c9b7500ea433aede3b8587af3bbbe727c8ebfd6f8a5942f6c0d14b0faa44b5" + }, + "Init.Data.FloatArray.Basic": { + "relative_path": "lib/lean/Init/Data/FloatArray/Basic.olean", + "sha256": "7169a26af51b7faaa9712ed85d9423a43b5c4f31ba4ccdbb3289eeaaf58e0afa" + }, + "Init.Data.Format": { + "relative_path": "lib/lean/Init/Data/Format.olean", + "sha256": "82528100ce60ae1eded58f45a0319b76ac7c80f9d834c60bec31cddd2a1f836b" + }, + "Init.Data.Format.Basic": { + "relative_path": "lib/lean/Init/Data/Format/Basic.olean", + "sha256": "7b7e7500d7a86ce98f996e4c6045c7fff49ee0efc72737cfc5ab4c284ad77f4a" + }, + "Init.Data.Format.Instances": { + "relative_path": "lib/lean/Init/Data/Format/Instances.olean", + "sha256": "b8bede2673426df8591cc8d2837854e12fd82f83132adcdb5d4fa6492b9f1d21" + }, + "Init.Data.Format.Macro": { + "relative_path": "lib/lean/Init/Data/Format/Macro.olean", + "sha256": "d4b42a5cd357e4c35a328183571bb8a919d2dba0e0241b081293c449b726ae35" + }, + "Init.Data.Format.Syntax": { + "relative_path": "lib/lean/Init/Data/Format/Syntax.olean", + "sha256": "3433640ca9aeb5ef96fda95bf9dc747d0feba236f3a3db2860f92970c5718882" + }, + "Init.Data.Function": { + "relative_path": "lib/lean/Init/Data/Function.olean", + "sha256": "17fa8cf9a33f44e97d1a3a8c77e086c567ef0520291421839b77b28fdbd2b8fa" + }, + "Init.Data.Hashable": { + "relative_path": "lib/lean/Init/Data/Hashable.olean", + "sha256": "0d9ba8712572cf7103ef0e4c1012f4c3d1b10bbc3f9d55409eb315ed87f26e7f" + }, + "Init.Data.Int": { + "relative_path": "lib/lean/Init/Data/Int.olean", + "sha256": "4628002a234694983f14e288745898d889aada1b0d9d9fbff5f3fb8dbb72c20a" + }, + "Init.Data.Int.Basic": { + "relative_path": "lib/lean/Init/Data/Int/Basic.olean", + "sha256": "926f11cf3beb5d66e06dc405f6aac7f39b38c440ba23baa26827ca79724b8eae" + }, + "Init.Data.Int.Bitwise": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise.olean", + "sha256": "527f601e3b6565c4e13a78e71c252c99f51b0203fba8e9a48bf61a6d702f7f77" + }, + "Init.Data.Int.Bitwise.Basic": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise/Basic.olean", + "sha256": "265104afaeebfc4163d1f1ab6bc8913ec7def48a6e0cf7c33a619e7c6b7996cd" + }, + "Init.Data.Int.Bitwise.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise/Lemmas.olean", + "sha256": "61fdbf3f93888946c2c76b36a1ac73246abd87048eb30a596d009a0dddfe3af0" + }, + "Init.Data.Int.Cooper": { + "relative_path": "lib/lean/Init/Data/Int/Cooper.olean", + "sha256": "607b77466cb24c6ae2b99b1bd054709dd7e315d0019d87854e45e588d2f4f061" + }, + "Init.Data.Int.DivMod": { + "relative_path": "lib/lean/Init/Data/Int/DivMod.olean", + "sha256": "0ac18881bb522630e818a1f973051dd26d51a7edfe6589132274694575627416" + }, + "Init.Data.Int.DivMod.Basic": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Basic.olean", + "sha256": "1bf5aad5de1a3d6931194060a4fe8fa304dced06404dd2815057179beecb7945" + }, + "Init.Data.Int.DivMod.Bootstrap": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Bootstrap.olean", + "sha256": "9f5e940c4fba88142e73ea864aee5257a1bf31566d3d67d1ebdd60967230d2c5" + }, + "Init.Data.Int.DivMod.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Lemmas.olean", + "sha256": "dbb9ae219e1f2072be3ed6986c5f713b1df79f563fab946fc903c7bcfdce7f48" + }, + "Init.Data.Int.Gcd": { + "relative_path": "lib/lean/Init/Data/Int/Gcd.olean", + "sha256": "294b7f9b1144098337d3b1eae9a286741c2a503388078bd601cf03bbc74e5af8" + }, + "Init.Data.Int.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/Lemmas.olean", + "sha256": "e447675a36f3fa775915d9c711e4172eb1575cb80d4f631ea9b4a0cf7319d791" + }, + "Init.Data.Int.LemmasAux": { + "relative_path": "lib/lean/Init/Data/Int/LemmasAux.olean", + "sha256": "f58eaab4a411b1dd8b2505d7b5479dc203c603ea9ee4a28dfc2e37ac6a1c50d3" + }, + "Init.Data.Int.Linear": { + "relative_path": "lib/lean/Init/Data/Int/Linear.olean", + "sha256": "a6f99acdf60bcb9b582ef87f01c9d53a76e61ea6466a7f4a9d5e4d5c9f564bc8" + }, + "Init.Data.Int.OfNat": { + "relative_path": "lib/lean/Init/Data/Int/OfNat.olean", + "sha256": "8b91634fcd25ef8639461730e11a2e30d7c0f479bd7c86064f1dbb0edf05d47c" + }, + "Init.Data.Int.Order": { + "relative_path": "lib/lean/Init/Data/Int/Order.olean", + "sha256": "32e716ca6845ff6b54befdb1d6fa157e6980471455c22c7c34a5fa1b206c5aaf" + }, + "Init.Data.Int.Pow": { + "relative_path": "lib/lean/Init/Data/Int/Pow.olean", + "sha256": "916584050412a63f5e067a8d86818a2576cd971f241d2bcce80da6ad9d2cebcd" + }, + "Init.Data.List": { + "relative_path": "lib/lean/Init/Data/List.olean", + "sha256": "a0b4ba4434de3cbe61e2009557a6b2c237e7ed24d903486b02efc2460594ebbe" + }, + "Init.Data.List.Attach": { + "relative_path": "lib/lean/Init/Data/List/Attach.olean", + "sha256": "1b460daad56a1203c465d63575d1fd1b0c417c9b22daa53d1239d3e3cf8858e3" + }, + "Init.Data.List.Basic": { + "relative_path": "lib/lean/Init/Data/List/Basic.olean", + "sha256": "45f40cdc05ba064b67aff84c6957f82c4a2e6edd0052fa508cc749e9d35999e1" + }, + "Init.Data.List.BasicAux": { + "relative_path": "lib/lean/Init/Data/List/BasicAux.olean", + "sha256": "210a850a3c6f96fb462b42a67920eed86b41cdfafd32adb39a272d4f66ab09fe" + }, + "Init.Data.List.Control": { + "relative_path": "lib/lean/Init/Data/List/Control.olean", + "sha256": "b082dae0a9caf27e9ebecc9d183598e091016f323b6b1c30942bfe9ac14915b6" + }, + "Init.Data.List.Count": { + "relative_path": "lib/lean/Init/Data/List/Count.olean", + "sha256": "37e1a1a86c77f09c1ae6f13af53e9f0fbc8dd888485e1796b1c0b2813904811a" + }, + "Init.Data.List.Erase": { + "relative_path": "lib/lean/Init/Data/List/Erase.olean", + "sha256": "2ff3cc2f53a947bba4110106d48bd8e6a746fbdbccda3d3168988377f9bf08d6" + }, + "Init.Data.List.FinRange": { + "relative_path": "lib/lean/Init/Data/List/FinRange.olean", + "sha256": "174b84f766bfad55861d5f9bf45051d705e4762491232c25589eda8491aee1fb" + }, + "Init.Data.List.Find": { + "relative_path": "lib/lean/Init/Data/List/Find.olean", + "sha256": "10dabc67b4e589018d889930fc75a663a75d91c7f083095e5892c3e359019d1d" + }, + "Init.Data.List.Impl": { + "relative_path": "lib/lean/Init/Data/List/Impl.olean", + "sha256": "1e62f8c4f057317bb61e73e76f39cbd3b699c7a45c168ab405f7c2cf35c3d2fe" + }, + "Init.Data.List.Lemmas": { + "relative_path": "lib/lean/Init/Data/List/Lemmas.olean", + "sha256": "ebcbcfb4dfc92e4eb9ece72b6c538b4809f96585313aef48cc91ed3e386f2ecc" + }, + "Init.Data.List.Lex": { + "relative_path": "lib/lean/Init/Data/List/Lex.olean", + "sha256": "3b9fb1bdab57ade29c2834da21d90ae802ccf7e58899b17ff487f6483c56ec72" + }, + "Init.Data.List.MapIdx": { + "relative_path": "lib/lean/Init/Data/List/MapIdx.olean", + "sha256": "bd024799a195c348a5937950048fddade6c7cc32ca43abc8e93a0d77c9593f3c" + }, + "Init.Data.List.MinMax": { + "relative_path": "lib/lean/Init/Data/List/MinMax.olean", + "sha256": "1fc6795971ac8f3530113326fb3e351626a4146db9c4772152b2ffe4a3bb81e1" + }, + "Init.Data.List.Monadic": { + "relative_path": "lib/lean/Init/Data/List/Monadic.olean", + "sha256": "82900949d78e7fc5b7c6415194cba03b2526409b350a39f923a78d9911132448" + }, + "Init.Data.List.Nat": { + "relative_path": "lib/lean/Init/Data/List/Nat.olean", + "sha256": "7963464ebb33af6223be0712ffb5bbe47c4587ae5380a61cbc5c6021baf9b422" + }, + "Init.Data.List.Nat.BEq": { + "relative_path": "lib/lean/Init/Data/List/Nat/BEq.olean", + "sha256": "fa52c59704dd8e1822d4b0257d670aedbb2f82017b74303bf358af42d494a450" + }, + "Init.Data.List.Nat.Basic": { + "relative_path": "lib/lean/Init/Data/List/Nat/Basic.olean", + "sha256": "745ae4e831f8597a5165d4dc9abc953c280a450a6547963f109c0fc18cbd6746" + }, + "Init.Data.List.Nat.Count": { + "relative_path": "lib/lean/Init/Data/List/Nat/Count.olean", + "sha256": "73ccebc5a9a303a8a9f2c9137d3fb60c3191b4d74c40370e53dc15e781536493" + }, + "Init.Data.List.Nat.Erase": { + "relative_path": "lib/lean/Init/Data/List/Nat/Erase.olean", + "sha256": "b8d0f4703d71d05efc7c94d8d2c2bad1278f1c65302ce0ee11275e93857f3b3c" + }, + "Init.Data.List.Nat.Find": { + "relative_path": "lib/lean/Init/Data/List/Nat/Find.olean", + "sha256": "73d6e91b894c9907bdb3a7087fa1fcc174fe4a96aac39055a797b84b8ec5f26a" + }, + "Init.Data.List.Nat.InsertIdx": { + "relative_path": "lib/lean/Init/Data/List/Nat/InsertIdx.olean", + "sha256": "5c5ac7ada578ca3a04908c1c6b94e2f12e684da28a3534fd8e2fb1712ba06a38" + }, + "Init.Data.List.Nat.Modify": { + "relative_path": "lib/lean/Init/Data/List/Nat/Modify.olean", + "sha256": "275e5291a6691082786680f93b2e0d09710e0fbcd9640b6503bbbf35041756aa" + }, + "Init.Data.List.Nat.Pairwise": { + "relative_path": "lib/lean/Init/Data/List/Nat/Pairwise.olean", + "sha256": "8aae1be95bb7c08d8e20bde2bdc46d737a4c54c6c132fb093782603e11f88e36" + }, + "Init.Data.List.Nat.Perm": { + "relative_path": "lib/lean/Init/Data/List/Nat/Perm.olean", + "sha256": "d34b546b7057199bf2b89b45908696cdc173bcbb8ff6e14c20e8553fce164014" + }, + "Init.Data.List.Nat.Range": { + "relative_path": "lib/lean/Init/Data/List/Nat/Range.olean", + "sha256": "56804bb0f398b27aba960edeff1d44703f3d59c67c72f540b9e4016fe7e005a3" + }, + "Init.Data.List.Nat.Sublist": { + "relative_path": "lib/lean/Init/Data/List/Nat/Sublist.olean", + "sha256": "cb179f24812905731bee16e0aabbf5eda0d6e1a07d693a0297798e3fab4316ab" + }, + "Init.Data.List.Nat.TakeDrop": { + "relative_path": "lib/lean/Init/Data/List/Nat/TakeDrop.olean", + "sha256": "86594d76cd6bca152ceabb5eaf14e7d2843b484cc2ae20233bf70eca4db3d470" + }, + "Init.Data.List.Notation": { + "relative_path": "lib/lean/Init/Data/List/Notation.olean", + "sha256": "231f63a53a24060f593b32f6321d2e5f1159bdb57172f5fd3e9ca2c38f137733" + }, + "Init.Data.List.OfFn": { + "relative_path": "lib/lean/Init/Data/List/OfFn.olean", + "sha256": "4d4a1feaf8df21b7567908a2723e0cd0bbb9ab1568a9cf1e6536c08a177c1119" + }, + "Init.Data.List.Pairwise": { + "relative_path": "lib/lean/Init/Data/List/Pairwise.olean", + "sha256": "6a00f9b67bb5554815fb9ca404ddf0f7df1fcb0c53d9b40a7de569f752a70779" + }, + "Init.Data.List.Perm": { + "relative_path": "lib/lean/Init/Data/List/Perm.olean", + "sha256": "16c720de1fc7adedfc438ed72845cdc53267779413765172a77e4540662d1a10" + }, + "Init.Data.List.Range": { + "relative_path": "lib/lean/Init/Data/List/Range.olean", + "sha256": "646ca36cfb7cb2359c5589af542f7b1714018cd2c2e06e705f38e8e69515ef29" + }, + "Init.Data.List.Sort": { + "relative_path": "lib/lean/Init/Data/List/Sort.olean", + "sha256": "c2718b7978559839c5c4493fa3a8efec0f89b75ba052319781ff102e2d4f874a" + }, + "Init.Data.List.Sort.Basic": { + "relative_path": "lib/lean/Init/Data/List/Sort/Basic.olean", + "sha256": "2358d6d69b08c0a229dd3fdc38598e300f65e534ac1a3db61495d2c68440b783" + }, + "Init.Data.List.Sort.Impl": { + "relative_path": "lib/lean/Init/Data/List/Sort/Impl.olean", + "sha256": "663f7c421f200455d1b5f73bbb1bc7698a83258cc2b8dd36d537f016f9eb9a77" + }, + "Init.Data.List.Sort.Lemmas": { + "relative_path": "lib/lean/Init/Data/List/Sort/Lemmas.olean", + "sha256": "8c31e71b3777de0363ff903a15fb77da2b64ca6e2a6df7e0f169c6fa6c68b9fc" + }, + "Init.Data.List.Sublist": { + "relative_path": "lib/lean/Init/Data/List/Sublist.olean", + "sha256": "626fc37b3fccd3ad01e524e497bed2e7470f69025ffb5c96477c5dda33cf93b8" + }, + "Init.Data.List.TakeDrop": { + "relative_path": "lib/lean/Init/Data/List/TakeDrop.olean", + "sha256": "6ad55d35f8158e3093612d2bd82b2fcc6e0e2692b89276374fbad91d05316236" + }, + "Init.Data.List.ToArray": { + "relative_path": "lib/lean/Init/Data/List/ToArray.olean", + "sha256": "d48db070507418071d7f3294285e8fd02ded1fe084445b6a728476fa0e5ef34b" + }, + "Init.Data.List.ToArrayImpl": { + "relative_path": "lib/lean/Init/Data/List/ToArrayImpl.olean", + "sha256": "877b70f91eb55124127734da7195914515b98abc3d601053119e4d10b3c749bf" + }, + "Init.Data.List.Zip": { + "relative_path": "lib/lean/Init/Data/List/Zip.olean", + "sha256": "b3ec8eed3d680c246fefdb0e57293acd2c2257a085937f2d1e026d118f6d3979" + }, + "Init.Data.Nat": { + "relative_path": "lib/lean/Init/Data/Nat.olean", + "sha256": "3447a7734bddbbc6904f5135e848dbca25c10bc5b6fad83b1beb09ac5bdb1fae" + }, + "Init.Data.Nat.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Basic.olean", + "sha256": "b2d11a9c4afa558c793fa12d41da087604ee0cf5dd8ee4f3c2f0b08e90031a50" + }, + "Init.Data.Nat.Bitwise": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise.olean", + "sha256": "ec84e12fb7c621de1fe2a6d0cf393bdec0b211e0741b6b343130d09417e0adc9" + }, + "Init.Data.Nat.Bitwise.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise/Basic.olean", + "sha256": "8f01e5e6af6b3366171fb8f21ba8a336c0ddef11a2a180b0fc033ef53757a69a" + }, + "Init.Data.Nat.Bitwise.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise/Lemmas.olean", + "sha256": "844179c496ff2ff5233abfec08e333e04170dd8b49a43f98ae15be7539b83b4b" + }, + "Init.Data.Nat.Compare": { + "relative_path": "lib/lean/Init/Data/Nat/Compare.olean", + "sha256": "9ce920efa06d6fb5e143925d07dd673e488640a5fc56c8c814ef41f383a0b6aa" + }, + "Init.Data.Nat.Control": { + "relative_path": "lib/lean/Init/Data/Nat/Control.olean", + "sha256": "126864791c444a3025fb8be008a42e792773f82535cb1fe9c80b6a9b0cbb0783" + }, + "Init.Data.Nat.Div.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Div/Basic.olean", + "sha256": "90ace86481881951b8aac0c78b829052894c5168bb81b4e32c48daefe634259e" + }, + "Init.Data.Nat.Div.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Div/Lemmas.olean", + "sha256": "06a8a626caa61480fa596adfa0fe6230b4b84cdbbf4f049da8a744dffa25efbc" + }, + "Init.Data.Nat.Dvd": { + "relative_path": "lib/lean/Init/Data/Nat/Dvd.olean", + "sha256": "36f58914fb3acef3f1b99aae4e1024647886c96f3575cd2cdb7b90e48b63a62f" + }, + "Init.Data.Nat.Fold": { + "relative_path": "lib/lean/Init/Data/Nat/Fold.olean", + "sha256": "ccbbc29df5d8b98e47f6d1ee36aa3cb036aa61c3adad7945bd72ef22117ecf0a" + }, + "Init.Data.Nat.Gcd": { + "relative_path": "lib/lean/Init/Data/Nat/Gcd.olean", + "sha256": "746fe45b4e8c648caebc10c1ba9e2736ebd492bb4854edc96c8d5c0f10905666" + }, + "Init.Data.Nat.Lcm": { + "relative_path": "lib/lean/Init/Data/Nat/Lcm.olean", + "sha256": "bbb02321b1e2b2422adf0d8c10b3800afe668a9edbb434e3dbd83c45386539de" + }, + "Init.Data.Nat.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Lemmas.olean", + "sha256": "7acb7e4f1b14d45188f28aa341f9013ee1c6bba8f0e1c2f3be74e04dd24b4782" + }, + "Init.Data.Nat.Linear": { + "relative_path": "lib/lean/Init/Data/Nat/Linear.olean", + "sha256": "33b034e32879e503ae843a62df9969d47e341eddf2650e299209e1494e507c2c" + }, + "Init.Data.Nat.Log2": { + "relative_path": "lib/lean/Init/Data/Nat/Log2.olean", + "sha256": "a1147619414a0561c2e404ca16b6f9c1b3e764fd66917d26964ff53d6f33d10b" + }, + "Init.Data.Nat.MinMax": { + "relative_path": "lib/lean/Init/Data/Nat/MinMax.olean", + "sha256": "813cd65d09f92a707754d8d86d35ae396b2ac77953076e7444021250799546dc" + }, + "Init.Data.Nat.Mod": { + "relative_path": "lib/lean/Init/Data/Nat/Mod.olean", + "sha256": "232fa20934aab58dfc025430ba91fe814d90e0e67f979a401fc91ea8a0fd06e3" + }, + "Init.Data.Nat.Power2": { + "relative_path": "lib/lean/Init/Data/Nat/Power2.olean", + "sha256": "aa68d47f1481ea940e4f2f3eeb5eb0cf44d9d36a81f02609f834bce92b36144a" + }, + "Init.Data.Nat.SOM": { + "relative_path": "lib/lean/Init/Data/Nat/SOM.olean", + "sha256": "be398ccbd96728c1500ab66aa2063131d37d6acd214067dbe14fb3a61150ff4d" + }, + "Init.Data.Nat.Simproc": { + "relative_path": "lib/lean/Init/Data/Nat/Simproc.olean", + "sha256": "491fdb35ea98fc6d352b6cb46c3681d42cb9e23f2df42a07a8e764b54ef7a62b" + }, + "Init.Data.NeZero": { + "relative_path": "lib/lean/Init/Data/NeZero.olean", + "sha256": "5fcec208f2769e4ec00ebf7dc0b534ffba76859d7390bac0ba36da69c8d06d0d" + }, + "Init.Data.OfScientific": { + "relative_path": "lib/lean/Init/Data/OfScientific.olean", + "sha256": "5a86fb094fc122609b959999bc53159282db03b2aba36b1d564270c95b630cc7" + }, + "Init.Data.Option": { + "relative_path": "lib/lean/Init/Data/Option.olean", + "sha256": "7cec7ba7cbb4f8c12b723822ef37fa80d7fe6dad55ffe781b04d480f37bee3e9" + }, + "Init.Data.Option.Attach": { + "relative_path": "lib/lean/Init/Data/Option/Attach.olean", + "sha256": "d13d8661e92455466e2652e81b0fc20660c6f68f61563e06ff9ada3b2adef85e" + }, + "Init.Data.Option.Basic": { + "relative_path": "lib/lean/Init/Data/Option/Basic.olean", + "sha256": "8a83ae7602811f2a8caa2f5ec890dfcaad71b7fee193f45329f23ce538838eae" + }, + "Init.Data.Option.BasicAux": { + "relative_path": "lib/lean/Init/Data/Option/BasicAux.olean", + "sha256": "69c9769a227956d0a18263f65759b2c78eeca5fc23df52fada29fae941be58b8" + }, + "Init.Data.Option.Instances": { + "relative_path": "lib/lean/Init/Data/Option/Instances.olean", + "sha256": "c2af58842fc1a5ace3156d8cc201a287eb79ad7707be50f11d43d9f6096452b8" + }, + "Init.Data.Option.Lemmas": { + "relative_path": "lib/lean/Init/Data/Option/Lemmas.olean", + "sha256": "832a8d1633685e7ace5ceb52ee44b1f441548ff85b6f15687314cc3709b9138e" + }, + "Init.Data.Option.List": { + "relative_path": "lib/lean/Init/Data/Option/List.olean", + "sha256": "919cbd303c6345f52d6c019146d46b4249daf12fe9fd3c2cfbece14797be8393" + }, + "Init.Data.Option.Monadic": { + "relative_path": "lib/lean/Init/Data/Option/Monadic.olean", + "sha256": "6f76327d567c5dbf041689c11ff396fdebbc832a1640d003ad2020671282aeb1" + }, + "Init.Data.Ord": { + "relative_path": "lib/lean/Init/Data/Ord.olean", + "sha256": "f9c47b462803dd4e251e3c89acc944998c255728461d0b038aa239e067c81a9c" + }, + "Init.Data.PLift": { + "relative_path": "lib/lean/Init/Data/PLift.olean", + "sha256": "2bed69175449aa3166dc103d9cf368e494b4d1752ed6e864250214256d710739" + }, + "Init.Data.Prod": { + "relative_path": "lib/lean/Init/Data/Prod.olean", + "sha256": "0498bf822d3922cd5bbc154bf0adef4fd76e4fe6a57f8e39fefa49ae9e16ca13" + }, + "Init.Data.Queue": { + "relative_path": "lib/lean/Init/Data/Queue.olean", + "sha256": "ab5118c07c9c0ed7d0819d19d442d1e6143f265f784f48151be1c4e2cd895606" + }, + "Init.Data.RArray": { + "relative_path": "lib/lean/Init/Data/RArray.olean", + "sha256": "9abe7370b3817a85b8512bc51dadc386f314bdcec188736b2f87405d5a9bb09b" + }, + "Init.Data.Random": { + "relative_path": "lib/lean/Init/Data/Random.olean", + "sha256": "5a34ed96d6a9814781db7e6c93847b8cd7caeb7071b2256058964866ec706af5" + }, + "Init.Data.Range": { + "relative_path": "lib/lean/Init/Data/Range.olean", + "sha256": "c64640dc9f5f61844778a90d7acc0f8f632ec11aa1746689c960d0f459bfaf46" + }, + "Init.Data.Range.Basic": { + "relative_path": "lib/lean/Init/Data/Range/Basic.olean", + "sha256": "bf692fd52dbffb6518f9a189179263fc4c49b436dbdb9eba2f00940de6665353" + }, + "Init.Data.Range.Lemmas": { + "relative_path": "lib/lean/Init/Data/Range/Lemmas.olean", + "sha256": "19e241eb048d7046e42e9117499d5bc8a43dddf66dacbb087966b4d16b82b06b" + }, + "Init.Data.Repr": { + "relative_path": "lib/lean/Init/Data/Repr.olean", + "sha256": "cbbd2014d6cee442d42c9c4d6997aa1e27dd3a4ea4fef43d1de4c1f184d02138" + }, + "Init.Data.SInt": { + "relative_path": "lib/lean/Init/Data/SInt.olean", + "sha256": "21f02e1e015c8ceee0e8afe9a24f8150714739a4df724b922e7b3f3756cc530d" + }, + "Init.Data.SInt.Basic": { + "relative_path": "lib/lean/Init/Data/SInt/Basic.olean", + "sha256": "c4b9b22f462ffe3dac0f5ce0d810e9cbbd3dda83a3c8f61aaca350f99edf30d9" + }, + "Init.Data.SInt.Bitwise": { + "relative_path": "lib/lean/Init/Data/SInt/Bitwise.olean", + "sha256": "784166152e7e37d32e49f556007eb9e8ac78a11e25a33159256124b1b6ac78b9" + }, + "Init.Data.SInt.Float": { + "relative_path": "lib/lean/Init/Data/SInt/Float.olean", + "sha256": "0fa2df58fc374f7d8f8381dc7369e0359fd56854418863015d82b50a49032bdd" + }, + "Init.Data.SInt.Float32": { + "relative_path": "lib/lean/Init/Data/SInt/Float32.olean", + "sha256": "08b0e06d73a8cc4989ef19e5b5dc0255aa458e852dade1660aeee88046199fb6" + }, + "Init.Data.SInt.Lemmas": { + "relative_path": "lib/lean/Init/Data/SInt/Lemmas.olean", + "sha256": "14f5714b32a97f7b89fe4f737e96d2d9576a75fdbdf62b848c26140b1be0d0b9" + }, + "Init.Data.Stream": { + "relative_path": "lib/lean/Init/Data/Stream.olean", + "sha256": "df7b2b39a4577fbe33f63d916ef4e0592fea0db8bc542b7e3f65bf8fca137950" + }, + "Init.Data.String": { + "relative_path": "lib/lean/Init/Data/String.olean", + "sha256": "44d46641afe72049132e8ba521b7e404190fb50b1710a008a531a6cb4bce4308" + }, + "Init.Data.String.Basic": { + "relative_path": "lib/lean/Init/Data/String/Basic.olean", + "sha256": "d7404ec9c0cedeb3e77cc7eadc3201e7cf1d44e1029407a279ce5dd2ab5537d1" + }, + "Init.Data.String.Extra": { + "relative_path": "lib/lean/Init/Data/String/Extra.olean", + "sha256": "5291234dedeae61b8f31129e9e8d90fcc2b91a784384250d36eea11c694e359a" + }, + "Init.Data.String.Lemmas": { + "relative_path": "lib/lean/Init/Data/String/Lemmas.olean", + "sha256": "e2fa260513d3ccaba3d0547bc5625ebbe09a171762e375b38b6dc1b8dc0fa6f5" + }, + "Init.Data.Subtype": { + "relative_path": "lib/lean/Init/Data/Subtype.olean", + "sha256": "1278a669b084dabde55a3f9a14c8b3ea7b7753b4b4d52bdbc1066bcb29f30208" + }, + "Init.Data.Sum": { + "relative_path": "lib/lean/Init/Data/Sum.olean", + "sha256": "0c08e5312a75c9474abf94ce7f6358efbdc6c178476005e36c22b5b294647930" + }, + "Init.Data.Sum.Basic": { + "relative_path": "lib/lean/Init/Data/Sum/Basic.olean", + "sha256": "30b5a85e6941f567feb412f1e6a4382d5c6d52558c4657285e80bd1b58879427" + }, + "Init.Data.Sum.Lemmas": { + "relative_path": "lib/lean/Init/Data/Sum/Lemmas.olean", + "sha256": "01ce321477e3f24f07aca5b0c4423c46d4c4e9533f25e00cdfd3f7e0af9ba319" + }, + "Init.Data.ToString": { + "relative_path": "lib/lean/Init/Data/ToString.olean", + "sha256": "bf141c2b4f750f8154aff447a05b8c02fc0231c48e550bf29823dd3a101b60a6" + }, + "Init.Data.ToString.Basic": { + "relative_path": "lib/lean/Init/Data/ToString/Basic.olean", + "sha256": "0892126af7fd71f9dd48a1f051af4f1ca5f181389a9b97dd7c759abcb8088fd0" + }, + "Init.Data.ToString.Macro": { + "relative_path": "lib/lean/Init/Data/ToString/Macro.olean", + "sha256": "3284b8ed0d3883ba46d39abb4d3620820bf6f12e47bfe3f33ead82ad80039580" + }, + "Init.Data.UInt": { + "relative_path": "lib/lean/Init/Data/UInt.olean", + "sha256": "a92781a10cb664f3b9dc344957d3c5c95bf9ec44fbe192cbb6ceac4c1d9f1391" + }, + "Init.Data.UInt.Basic": { + "relative_path": "lib/lean/Init/Data/UInt/Basic.olean", + "sha256": "d30c2c0bff573487362546d06fe7cf8fc0ae6dfead1379a1ad2523fc96795eb9" + }, + "Init.Data.UInt.BasicAux": { + "relative_path": "lib/lean/Init/Data/UInt/BasicAux.olean", + "sha256": "76e27df77fe31ef1d6b54d00a1758d579532a15787f4cfec7da774d535b47072" + }, + "Init.Data.UInt.Bitwise": { + "relative_path": "lib/lean/Init/Data/UInt/Bitwise.olean", + "sha256": "aa829cd7c8a6e68d0365d1662727646fc68b817428e469b33d96d057f6643d4e" + }, + "Init.Data.UInt.Lemmas": { + "relative_path": "lib/lean/Init/Data/UInt/Lemmas.olean", + "sha256": "5912f89a17ba6b111d9d7f3df46904b90811a4cdd80fc02a06984cd4c3dd3aa0" + }, + "Init.Data.UInt.Log2": { + "relative_path": "lib/lean/Init/Data/UInt/Log2.olean", + "sha256": "315c374ceeecdab0fde8042abffb68b082f063ce3ebf810efa46d89eb239faca" + }, + "Init.Data.ULift": { + "relative_path": "lib/lean/Init/Data/ULift.olean", + "sha256": "e1187f01e60437dc3c741cd1ba76657855642cc2574a59fa9a3be9a9e9d435b4" + }, + "Init.Data.Vector": { + "relative_path": "lib/lean/Init/Data/Vector.olean", + "sha256": "8ff79e5ffafceccc1bc38f3ac3d5ae7eb802c95cf1bd51393c6af7be6dfdea63" + }, + "Init.Data.Vector.Attach": { + "relative_path": "lib/lean/Init/Data/Vector/Attach.olean", + "sha256": "ecf089f945d2adcc57180f779593ccf0a2fa0c27d89968a7722b914f4b58b8af" + }, + "Init.Data.Vector.Basic": { + "relative_path": "lib/lean/Init/Data/Vector/Basic.olean", + "sha256": "afacc92812490337d7f03950905748563477bfe6494f046a0dfd9451aa4a4d65" + }, + "Init.Data.Vector.Count": { + "relative_path": "lib/lean/Init/Data/Vector/Count.olean", + "sha256": "b23fa70c6a9f0ea3b8ed1a4c811a2d0557751d4bb798e954d1ff985e00d492b1" + }, + "Init.Data.Vector.DecidableEq": { + "relative_path": "lib/lean/Init/Data/Vector/DecidableEq.olean", + "sha256": "4cf94f33d63c842c39f35392ce1bbf4c40ed1bfe9ec5161d522ba1442d8e0a2c" + }, + "Init.Data.Vector.Erase": { + "relative_path": "lib/lean/Init/Data/Vector/Erase.olean", + "sha256": "8c5cf30ba1225d74d85f93b3553f09e9299c182805f0efb44fad509ea5e56b78" + }, + "Init.Data.Vector.Extract": { + "relative_path": "lib/lean/Init/Data/Vector/Extract.olean", + "sha256": "0e12201859d76ac91415a74e00f909b32a631fefd2d2b5d7afeb0d2730bfa47a" + }, + "Init.Data.Vector.FinRange": { + "relative_path": "lib/lean/Init/Data/Vector/FinRange.olean", + "sha256": "b862166a52500e392a3cfab1b4b4f5d2b7b202725f48526a1e935ca52abdda38" + }, + "Init.Data.Vector.InsertIdx": { + "relative_path": "lib/lean/Init/Data/Vector/InsertIdx.olean", + "sha256": "c3f496caa69211325d18bc909f9be134bfd07515f8b95773b252004a71e01fc5" + }, + "Init.Data.Vector.Lemmas": { + "relative_path": "lib/lean/Init/Data/Vector/Lemmas.olean", + "sha256": "35726f2c825e29355e25d574a25470dba908ea9f680b92f4e6ab57ec77d47f3d" + }, + "Init.Data.Vector.Lex": { + "relative_path": "lib/lean/Init/Data/Vector/Lex.olean", + "sha256": "1541eb5302ac1fe618815bd36a3d4468f08003a6571118fc8322bbf155b441de" + }, + "Init.Data.Vector.MapIdx": { + "relative_path": "lib/lean/Init/Data/Vector/MapIdx.olean", + "sha256": "cbe812bbd7839fae0178d0c183d96d1f29f768b55349bebb47628f903c7cda57" + }, + "Init.Data.Vector.Monadic": { + "relative_path": "lib/lean/Init/Data/Vector/Monadic.olean", + "sha256": "c44bb39a17f785673f64d6e40116173d821d9184c41377371c5cb73565440a30" + }, + "Init.Data.Vector.OfFn": { + "relative_path": "lib/lean/Init/Data/Vector/OfFn.olean", + "sha256": "69f88342bdd241ebafeffb51ee94c1363ab096ea6d435ef4d062b1a552167cf4" + }, + "Init.Data.Vector.Range": { + "relative_path": "lib/lean/Init/Data/Vector/Range.olean", + "sha256": "88351024a2b10fd4648a0ae15e005d8799b95be7d0060c89a5a205a4fc40b56f" + }, + "Init.Data.Vector.Zip": { + "relative_path": "lib/lean/Init/Data/Vector/Zip.olean", + "sha256": "8c28067d8d5289ec3a5cbc9674643c688210c75813c69c0b66baba5ea29abaea" + }, + "Init.Data.Zero": { + "relative_path": "lib/lean/Init/Data/Zero.olean", + "sha256": "04d070309e7a1962ebcb5de2b2bfa69e5f5d4d54477689cbdbadb21202611dac" + }, + "Init.Dynamic": { + "relative_path": "lib/lean/Init/Dynamic.olean", + "sha256": "a9982d28dff48820a4e5310d473b53d19de91c1d1685749bccb849e881219fa1" + }, + "Init.Ext": { + "relative_path": "lib/lean/Init/Ext.olean", + "sha256": "1f32591106d111c224423e61d0afd89014b96aa77e9141c6bec47b33b80c31f7" + }, + "Init.GetElem": { + "relative_path": "lib/lean/Init/GetElem.olean", + "sha256": "2683b27cced90b5fbfbe5213c309ed94bf423edf90924a1002eea72b152fdb58" + }, + "Init.Grind": { + "relative_path": "lib/lean/Init/Grind.olean", + "sha256": "33eff60d5cea8bd5db12879a12cf1a1cf772b1a2ab778136cc138685bc23654a" + }, + "Init.Grind.Cases": { + "relative_path": "lib/lean/Init/Grind/Cases.olean", + "sha256": "d086d84578922287a95fedee2f43e884a629e838c2ff8e71efc2910510509594" + }, + "Init.Grind.Lemmas": { + "relative_path": "lib/lean/Init/Grind/Lemmas.olean", + "sha256": "ca22a5c6a54190290fc558e7805244c66c3c044c3a708a98300703d70bef11ec" + }, + "Init.Grind.Norm": { + "relative_path": "lib/lean/Init/Grind/Norm.olean", + "sha256": "3f889971f8415ffff0f737c2214d5be92be1294398624aec1c9d9bd45942dd66" + }, + "Init.Grind.Offset": { + "relative_path": "lib/lean/Init/Grind/Offset.olean", + "sha256": "4f95e7282b636fe3690d8b159425a37bf5bb2f80c49e7ccdd6170b6977148d50" + }, + "Init.Grind.PP": { + "relative_path": "lib/lean/Init/Grind/PP.olean", + "sha256": "d94c99691443ce7517096899dc89ffd3a1eff62b621e530ff98e46ff7a9e4407" + }, + "Init.Grind.Propagator": { + "relative_path": "lib/lean/Init/Grind/Propagator.olean", + "sha256": "e292ef4b9a9a4475f7c6eb767ddc84d8b5f0a30feabbbb1664966930e050496f" + }, + "Init.Grind.Tactics": { + "relative_path": "lib/lean/Init/Grind/Tactics.olean", + "sha256": "8c21109288355c0969f3fae78c66756b2a73699d4170d53336d0825a82b2b82d" + }, + "Init.Grind.Util": { + "relative_path": "lib/lean/Init/Grind/Util.olean", + "sha256": "666cf848a9a3ba30885be219a767d96bd2b6582fde19f84110c3c583308c5e8f" + }, + "Init.Guard": { + "relative_path": "lib/lean/Init/Guard.olean", + "sha256": "3bec2e0ab8c2829d1d13c64c80fb983b5d5f115a67b29ee64eedbe3f6628a470" + }, + "Init.Hints": { + "relative_path": "lib/lean/Init/Hints.olean", + "sha256": "5c814650ff2f23259cc67c04ab1a438222ec084d4369aca679fd0cc07cbb5474" + }, + "Init.Internal": { + "relative_path": "lib/lean/Init/Internal.olean", + "sha256": "2927550a155fb6115ac63e31cc35f9969047a6c015ced8325ce769d5631c0200" + }, + "Init.Internal.Order": { + "relative_path": "lib/lean/Init/Internal/Order.olean", + "sha256": "37884830614f3f48f325497beadc3cc60f0e363a1846cdcc28221ca05ba39759" + }, + "Init.Internal.Order.Basic": { + "relative_path": "lib/lean/Init/Internal/Order/Basic.olean", + "sha256": "c0b362116c8f553cc59964154fdc9a3418672bf9b5caee2b745608f40aa71091" + }, + "Init.Internal.Order.Lemmas": { + "relative_path": "lib/lean/Init/Internal/Order/Lemmas.olean", + "sha256": "198fb9d38168f2116937d641fa5419c99e0e9c03c0f630756f68affca451c1e0" + }, + "Init.Internal.Order.Tactic": { + "relative_path": "lib/lean/Init/Internal/Order/Tactic.olean", + "sha256": "d519c1d64b866e639de30ef452587bbe8802c64536e6ee541e47fcc7be3f942d" + }, + "Init.MacroTrace": { + "relative_path": "lib/lean/Init/MacroTrace.olean", + "sha256": "49d356d5728ea1a0ed6a14cbca10b6387f99d40b85602189566c4e4c1d6cc524" + }, + "Init.Meta": { + "relative_path": "lib/lean/Init/Meta.olean", + "sha256": "16b7ad338addb717e0eb584fc583a2e9d4e08242040654a2d3546650cb71bddc" + }, + "Init.MetaTypes": { + "relative_path": "lib/lean/Init/MetaTypes.olean", + "sha256": "1aa89a88743c9d8f66daecc6f28a7a7816efad55a42129bca1e2220450747bd8" + }, + "Init.Notation": { + "relative_path": "lib/lean/Init/Notation.olean", + "sha256": "576706b70dc9f21b093c7b10755e25c2f3fea8f04586b128893308730d715dae" + }, + "Init.NotationExtra": { + "relative_path": "lib/lean/Init/NotationExtra.olean", + "sha256": "92ba272c0a25c97e7800cdf2e948bb20e374861d28d31736d80a757b7dd852b0" + }, + "Init.Omega": { + "relative_path": "lib/lean/Init/Omega.olean", + "sha256": "ef46ae7141263a8f3168ddc0de5b10c37cd991f907e6558d6a10daed027950ad" + }, + "Init.Omega.Coeffs": { + "relative_path": "lib/lean/Init/Omega/Coeffs.olean", + "sha256": "a7f2688fb1799c93744fb62301026c37c58ee81d58eb91e80041622397bd1dd3" + }, + "Init.Omega.Constraint": { + "relative_path": "lib/lean/Init/Omega/Constraint.olean", + "sha256": "1e5a89907d661084e3223c006975f275efbe03df7c43fd18a68425798ac09189" + }, + "Init.Omega.Int": { + "relative_path": "lib/lean/Init/Omega/Int.olean", + "sha256": "335df595a7449bc9ab310b9a5914bcae3ad6219121cd1f67261deb8383b5d61d" + }, + "Init.Omega.IntList": { + "relative_path": "lib/lean/Init/Omega/IntList.olean", + "sha256": "315f3755c1bdb87eda3449e97cb3141b9bc69b88af3faa93b0c54a5bf16137bf" + }, + "Init.Omega.LinearCombo": { + "relative_path": "lib/lean/Init/Omega/LinearCombo.olean", + "sha256": "6f254b2ed1ea5d35519b633f58da229500dca18293b3d958c7f93cc6a7e64e67" + }, + "Init.Omega.Logic": { + "relative_path": "lib/lean/Init/Omega/Logic.olean", + "sha256": "c8b7e60bd2aeee6efbab4f4787a5eddcb8b6ccb02841b7948b5120b5dbc7f5be" + }, + "Init.Prelude": { + "relative_path": "lib/lean/Init/Prelude.olean", + "sha256": "db4e87c0006f1303f3d41ca9a615a4890ca94309812bda09476677ea9bb5d672" + }, + "Init.PropLemmas": { + "relative_path": "lib/lean/Init/PropLemmas.olean", + "sha256": "f95cab4646f43dbaca3fc915bbd32868f0ac73aaeba818d165843e276499542e" + }, + "Init.RCases": { + "relative_path": "lib/lean/Init/RCases.olean", + "sha256": "aa216281d8930fe16cdb7b6b1f604066e824b33eaf62870d41391040c2ba77b4" + }, + "Init.ShareCommon": { + "relative_path": "lib/lean/Init/ShareCommon.olean", + "sha256": "c2647e2778a9bf01ffdc302ea5604308036ee982de23feac85ce21805f0b3ba8" + }, + "Init.SimpLemmas": { + "relative_path": "lib/lean/Init/SimpLemmas.olean", + "sha256": "37b58f69317f08a8e55d1f3950c4d00ccb29ebed135eb5e9789e8feb4f412369" + }, + "Init.Simproc": { + "relative_path": "lib/lean/Init/Simproc.olean", + "sha256": "53b36872b429c61141ac340011f233e680f82ccced2fb43fabf9fbeca5807040" + }, + "Init.SizeOf": { + "relative_path": "lib/lean/Init/SizeOf.olean", + "sha256": "0b2e2a18d9b699a5236c79acca835fd68f5400bbd998ca5743825c5734b6d589" + }, + "Init.SizeOfLemmas": { + "relative_path": "lib/lean/Init/SizeOfLemmas.olean", + "sha256": "ef5ba22b92506575f987eaea9cb87eda5a1d870da071e53f1257cb1cc999fd85" + }, + "Init.Syntax": { + "relative_path": "lib/lean/Init/Syntax.olean", + "sha256": "55eab3582563a12c40c7797ed6d06db613c855508c3138df975d2613422f6399" + }, + "Init.System": { + "relative_path": "lib/lean/Init/System.olean", + "sha256": "7a0e2f92d28211ac4da2835c7b15db71b08799d68e0c759c0f899b7c19ef564c" + }, + "Init.System.FilePath": { + "relative_path": "lib/lean/Init/System/FilePath.olean", + "sha256": "cdc4f4ecf0cd8470047e8c1e706d22f7321bee3072e44a669481e56689e187f1" + }, + "Init.System.IO": { + "relative_path": "lib/lean/Init/System/IO.olean", + "sha256": "069217c5d17f79433867ec6f701a5702cb40c88485dedc61be1f1ce0ef9b44fb" + }, + "Init.System.IOError": { + "relative_path": "lib/lean/Init/System/IOError.olean", + "sha256": "6e1ff344b12e6d7fcbb7abea99eaa3c88ae2626dd669d7f3c545822f96494ec2" + }, + "Init.System.Mutex": { + "relative_path": "lib/lean/Init/System/Mutex.olean", + "sha256": "fc950b4b00a1c3104ea945a9a93ab51807521b29a0b83518127de77eb3f76922" + }, + "Init.System.Platform": { + "relative_path": "lib/lean/Init/System/Platform.olean", + "sha256": "b679564c6df441632b6277f089cd588220ae5c4b8ae519873dc3172bb3091e52" + }, + "Init.System.Promise": { + "relative_path": "lib/lean/Init/System/Promise.olean", + "sha256": "78dc6c800d0f873e6520dbcf32c9dda22370563c75f086fb03e25fae393e848c" + }, + "Init.System.ST": { + "relative_path": "lib/lean/Init/System/ST.olean", + "sha256": "3fc620f17a5cb9e2243d760ffcb7ede9227b8c639c9376ff25c6bea1a7c1a7e7" + }, + "Init.System.Uri": { + "relative_path": "lib/lean/Init/System/Uri.olean", + "sha256": "d1a020ceeb21e6358fb0768345f90866752ef2dfe6c9dec71f388bd34b919de3" + }, + "Init.Tactics": { + "relative_path": "lib/lean/Init/Tactics.olean", + "sha256": "285e86e84ef77045b1f4944cacef6f11bca49334671808adec30f2e6fafd0dd8" + }, + "Init.TacticsExtra": { + "relative_path": "lib/lean/Init/TacticsExtra.olean", + "sha256": "e0521889dab4e1a74e8a407a0a0409109723ab9363b4be234115dc80aa01b5ba" + }, + "Init.Task": { + "relative_path": "lib/lean/Init/Task.olean", + "sha256": "effc51f55f006a6e54f0bb4b6577f7fe6a92d79958a0f3dfd258e4c53b9fa3c8" + }, + "Init.Try": { + "relative_path": "lib/lean/Init/Try.olean", + "sha256": "d289104c53a554fd4e7d8b81d5fd8212dcca854e6dec5cf80e088e3545a23c6b" + }, + "Init.Util": { + "relative_path": "lib/lean/Init/Util.olean", + "sha256": "da825c487c1ff3bf957f8ef84fade6ca10e2428807f84f52613551e11a404f03" + }, + "Init.WF": { + "relative_path": "lib/lean/Init/WF.olean", + "sha256": "16d58f1a3442679940e0f5d0eb9fd209e6eae04f7f4550dd7361847f0ba97082" + }, + "Init.WFTactics": { + "relative_path": "lib/lean/Init/WFTactics.olean", + "sha256": "edeb5134b3fc1f3234ef027a4d803b733c75a7174ac2a4bfe8a6353f783deb32" + }, + "Init.While": { + "relative_path": "lib/lean/Init/While.olean", + "sha256": "6fc8fbe7c581376a6826126ce6aacb031231cdc32afb135dfa3bfda884305625" + }, + "Lean": { + "relative_path": "lib/lean/Lean.olean", + "sha256": "7b09317fc9d21262dbfbb6f014dc40c2809b55e6cbb4f7587211a57ec91f7221" + }, + "Lean.AddDecl": { + "relative_path": "lib/lean/Lean/AddDecl.olean", + "sha256": "ec30e087524b32520021eeb3dc8c2d0aefdce838f11dd8e57f13cf1f05611cf8" + }, + "Lean.Attributes": { + "relative_path": "lib/lean/Lean/Attributes.olean", + "sha256": "e4db4a704b0260d6e36f4f542416091124e09767dc8bc759d2b1adbe53e9c166" + }, + "Lean.AuxRecursor": { + "relative_path": "lib/lean/Lean/AuxRecursor.olean", + "sha256": "8ad6ecf040763b62561819bb75de71763765566d01e68d3ed60fe27ff1b70b92" + }, + "Lean.BuiltinDocAttr": { + "relative_path": "lib/lean/Lean/BuiltinDocAttr.olean", + "sha256": "c9fb01241ff340cc8cdba6efffa553449f24748d42f0966903ce7b3038a6f266" + }, + "Lean.Class": { + "relative_path": "lib/lean/Lean/Class.olean", + "sha256": "0a41587a7d43178adb832ac6a835a3ded745f5b94f031b8a7fa916a6de2d681c" + }, + "Lean.Compiler": { + "relative_path": "lib/lean/Lean/Compiler.olean", + "sha256": "60a1e6cb63d9ee93f449d816b9d5f35d550da07c2ed98d4574cc00610aaa1fcc" + }, + "Lean.Compiler.AtMostOnce": { + "relative_path": "lib/lean/Lean/Compiler/AtMostOnce.olean", + "sha256": "46d86c6dc85f433a42dfa3a3162ed82530e0efd6d0def6857c447342776280b5" + }, + "Lean.Compiler.BorrowedAnnotation": { + "relative_path": "lib/lean/Lean/Compiler/BorrowedAnnotation.olean", + "sha256": "dfd99a6b65e28ce3c81d6effb32273e088fcce5829cbaeec57a98a4f325c70a8" + }, + "Lean.Compiler.CSimpAttr": { + "relative_path": "lib/lean/Lean/Compiler/CSimpAttr.olean", + "sha256": "4228ef18768f8fd70d1c48c5a5e9c7e0736e84389e0cc291d45ea6ef55853c85" + }, + "Lean.Compiler.ClosedTermCache": { + "relative_path": "lib/lean/Lean/Compiler/ClosedTermCache.olean", + "sha256": "332d9fcc102a8ec05d9d450f835de662c8b153274e86f4e8f8bf72bb7c0c86fa" + }, + "Lean.Compiler.ConstFolding": { + "relative_path": "lib/lean/Lean/Compiler/ConstFolding.olean", + "sha256": "a0f0396a65891075ef27848bf3578a2b14c5d9fa295ee982014d97cae25ec46c" + }, + "Lean.Compiler.ExportAttr": { + "relative_path": "lib/lean/Lean/Compiler/ExportAttr.olean", + "sha256": "f0975b5550d69d83ad3b27d0ad2363641167e47178788f22890be83d3e5511e6" + }, + "Lean.Compiler.ExternAttr": { + "relative_path": "lib/lean/Lean/Compiler/ExternAttr.olean", + "sha256": "c015f64d0e192ec7b6774ea02f82e8d210aa29022cc9317ba1f44f4d1db03983" + }, + "Lean.Compiler.FFI": { + "relative_path": "lib/lean/Lean/Compiler/FFI.olean", + "sha256": "5c592270389ca3547b225d542569d17074a72aab1d3069972aa13183c9defb4b" + }, + "Lean.Compiler.IR": { + "relative_path": "lib/lean/Lean/Compiler/IR.olean", + "sha256": "c0d443734bf92a204df7d44fb5b213073d860465d1940beb4f56be04fe95fa5d" + }, + "Lean.Compiler.IR.Basic": { + "relative_path": "lib/lean/Lean/Compiler/IR/Basic.olean", + "sha256": "256c663d51575e663739cf47717d5b563d91bccd233443d8c71ff95eb81ccf2b" + }, + "Lean.Compiler.IR.Borrow": { + "relative_path": "lib/lean/Lean/Compiler/IR/Borrow.olean", + "sha256": "76ccf72d60d34df08de11583942e4978c88f79daea6c48a34aee9b0b0164a143" + }, + "Lean.Compiler.IR.Boxing": { + "relative_path": "lib/lean/Lean/Compiler/IR/Boxing.olean", + "sha256": "ba56d60339b940f7b1d5f1bc244145dd90c835bd7a7c22501af7ab4eb502c7e9" + }, + "Lean.Compiler.IR.Checker": { + "relative_path": "lib/lean/Lean/Compiler/IR/Checker.olean", + "sha256": "0760b0f827e3f94462f855b0cde1e99a4f2ececa4dc914bb36ccc7388d05ea1f" + }, + "Lean.Compiler.IR.CompilerM": { + "relative_path": "lib/lean/Lean/Compiler/IR/CompilerM.olean", + "sha256": "3c51c9bc8b5684d2b997424a46ecfffd0faebaeccc20871faa6142bbdee6261e" + }, + "Lean.Compiler.IR.CtorLayout": { + "relative_path": "lib/lean/Lean/Compiler/IR/CtorLayout.olean", + "sha256": "41b6538779aec55878034a4311f5ec5afb609ee355306207f63d480beec7d8f1" + }, + "Lean.Compiler.IR.ElimDeadBranches": { + "relative_path": "lib/lean/Lean/Compiler/IR/ElimDeadBranches.olean", + "sha256": "db8b2361ec98aeab4251a3f24b6bdd6dfea6560736a7e2db580ac80ea5a19088" + }, + "Lean.Compiler.IR.ElimDeadVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/ElimDeadVars.olean", + "sha256": "fa545c9536767b2921812ec4f12787dbafdb12fba219c37c50ef08406aed35c0" + }, + "Lean.Compiler.IR.EmitC": { + "relative_path": "lib/lean/Lean/Compiler/IR/EmitC.olean", + "sha256": "8d3cc7f7314b0540efc952a891d2c04b146a0e974c78698f257aa84218e22fa8" + }, + "Lean.Compiler.IR.EmitUtil": { + "relative_path": "lib/lean/Lean/Compiler/IR/EmitUtil.olean", + "sha256": "d94b654927d21d70638e7be9f071d042f1ddef03ffb35c8e1873ce06f6bc0bec" + }, + "Lean.Compiler.IR.ExpandResetReuse": { + "relative_path": "lib/lean/Lean/Compiler/IR/ExpandResetReuse.olean", + "sha256": "52056b452d80b3cc358d961c340c878bd8fd439c4157f19579ab24b6e45beb63" + }, + "Lean.Compiler.IR.Format": { + "relative_path": "lib/lean/Lean/Compiler/IR/Format.olean", + "sha256": "7ce035303406e57cca579f9730815aae11392a6b068ebfb1ae5563989ef9d648" + }, + "Lean.Compiler.IR.FreeVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/FreeVars.olean", + "sha256": "b7689c40b2b8acb573130f0678e945f7de1f93cc0d2cc516992b735d3b16600c" + }, + "Lean.Compiler.IR.LiveVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/LiveVars.olean", + "sha256": "04dffa3befd0baf2b1caabada126812e8799e0842e88ae55d2f9f435b210bba7" + }, + "Lean.Compiler.IR.NormIds": { + "relative_path": "lib/lean/Lean/Compiler/IR/NormIds.olean", + "sha256": "42d1c0c091dd6795dc22f817e1bbd69f8a023744028d476ee73c3d47b9094507" + }, + "Lean.Compiler.IR.PushProj": { + "relative_path": "lib/lean/Lean/Compiler/IR/PushProj.olean", + "sha256": "45d3a0ef752e7ec5a2868af25c01793a0e9763307b35d8821fb1aeeb0886e5e7" + }, + "Lean.Compiler.IR.RC": { + "relative_path": "lib/lean/Lean/Compiler/IR/RC.olean", + "sha256": "efe9f4218bc3bc9ff1df43dbd6d5d5629c6914bc69834a1642f67aa16b9c7a1c" + }, + "Lean.Compiler.IR.ResetReuse": { + "relative_path": "lib/lean/Lean/Compiler/IR/ResetReuse.olean", + "sha256": "efe1a6814901274604fe1e6ada5e6819c56a50ade0732c255a5fabbac86b90f0" + }, + "Lean.Compiler.IR.SimpCase": { + "relative_path": "lib/lean/Lean/Compiler/IR/SimpCase.olean", + "sha256": "3c29f2a2fc5a04a44b6afa8c945055dc63aaee07fa17412c49f32b66b93af17b" + }, + "Lean.Compiler.IR.Sorry": { + "relative_path": "lib/lean/Lean/Compiler/IR/Sorry.olean", + "sha256": "4f931aed57566e1db5097e0703d072434871fcfad52bedd7afefda28c9e28b49" + }, + "Lean.Compiler.IR.UnboxResult": { + "relative_path": "lib/lean/Lean/Compiler/IR/UnboxResult.olean", + "sha256": "7a27c69a4b077ee78cd5c060dab56b7af05e02428073627d28ccdff330e74670" + }, + "Lean.Compiler.ImplementedByAttr": { + "relative_path": "lib/lean/Lean/Compiler/ImplementedByAttr.olean", + "sha256": "0bdd1c11d87a3e766eb8372e72dbdc72606b0367551455d1ff3093d50a14ba0e" + }, + "Lean.Compiler.InitAttr": { + "relative_path": "lib/lean/Lean/Compiler/InitAttr.olean", + "sha256": "a4b773a972dd41b77fa8973f7c570e3c2f1eef2a56e36c6b5b91a9543fe23efd" + }, + "Lean.Compiler.InlineAttrs": { + "relative_path": "lib/lean/Lean/Compiler/InlineAttrs.olean", + "sha256": "1dc521edbac6c28fb0abe0b1bfa72372d225b00d184228cb135fea3b3900583c" + }, + "Lean.Compiler.LCNF": { + "relative_path": "lib/lean/Lean/Compiler/LCNF.olean", + "sha256": "50ba85811e79db199dcc8528997fe62c599b3e36bae0bff0c56da744a975815e" + }, + "Lean.Compiler.LCNF.AlphaEqv": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/AlphaEqv.olean", + "sha256": "3e525daf1858d10b3c576598392a797f9bc77af47c88877a81f4b80f95e39f60" + }, + "Lean.Compiler.LCNF.AuxDeclCache": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/AuxDeclCache.olean", + "sha256": "e4ebfeac04cc04ab322e324c6b5cceb5fb0049899d323ace2185ed1d82f20460" + }, + "Lean.Compiler.LCNF.BaseTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/BaseTypes.olean", + "sha256": "5053822e35b6065475c75ea4121fb7c0e5572473b589a6318c23d8245cb91031" + }, + "Lean.Compiler.LCNF.Basic": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Basic.olean", + "sha256": "61a9c336f3fc892426f33ce054488c33e6c853038561acc10f6e68f1c4dae86f" + }, + "Lean.Compiler.LCNF.Bind": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Bind.olean", + "sha256": "ddcb0976ae13b967a67b86197dd84df7911382cfc311cc72f1643bcde382170e" + }, + "Lean.Compiler.LCNF.CSE": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CSE.olean", + "sha256": "0f30cf963d74e913c63d6a61eb2e6024a51aae3598e1bb7d67fe68e2571983b1" + }, + "Lean.Compiler.LCNF.Check": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Check.olean", + "sha256": "bfa8071c59de426aaa04e96c0c7cc9adabcba58266af88e878efc333efa217cc" + }, + "Lean.Compiler.LCNF.Closure": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Closure.olean", + "sha256": "8e07eaf84941feda5b4549dcbbfa53cd0981cf41053d3cb7604de6b37055b89c" + }, + "Lean.Compiler.LCNF.CompatibleTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CompatibleTypes.olean", + "sha256": "bbbd5d8598de30d40edc079da53afced3be253be5f5bc1ba5098b673a39178a7" + }, + "Lean.Compiler.LCNF.CompilerM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CompilerM.olean", + "sha256": "0dba55f8281250c8f7c8ca16d327e9c699a12bc22b7a740cc4494c9807071148" + }, + "Lean.Compiler.LCNF.ConfigOptions": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ConfigOptions.olean", + "sha256": "911b57609345802250709851c15ca20bb8b0c72d7cd38eb43691c09523cec4a7" + }, + "Lean.Compiler.LCNF.DeclHash": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/DeclHash.olean", + "sha256": "5e269b1f1ac7904fb9ebb77fe9805065fbb378fecf06eef5f123dc27a84b8555" + }, + "Lean.Compiler.LCNF.DependsOn": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/DependsOn.olean", + "sha256": "e7d096fac73063f27b1fc6f49c0eb5c4b7edb7075115cae9f2635e894fc7b070" + }, + "Lean.Compiler.LCNF.ElimDead": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ElimDead.olean", + "sha256": "477333313db8979680b9ee364d3075b5162225b83a69c60f18afca99f5f184c9" + }, + "Lean.Compiler.LCNF.ElimDeadBranches": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ElimDeadBranches.olean", + "sha256": "67ca5f89e780bfa7c0e62c0318b038421385dd3d9165ee207e2ba55a8edc3b50" + }, + "Lean.Compiler.LCNF.FVarUtil": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FVarUtil.olean", + "sha256": "d15ee92fbc441d2a5805f9fd5f851c49dd7267fc259d058273771168ce44b2b4" + }, + "Lean.Compiler.LCNF.FixedParams": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FixedParams.olean", + "sha256": "02e113791b21bc00471cc5e650e0167187e9b60993dc1627c1a0591cf9e928dc" + }, + "Lean.Compiler.LCNF.FloatLetIn": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FloatLetIn.olean", + "sha256": "aa1a425efb344b0216c4d87f584165e314acc54702788de99d359010f51cd5ef" + }, + "Lean.Compiler.LCNF.InferType": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/InferType.olean", + "sha256": "b91d6fbb425074a2e8296fbc557159c22b409e8f2ffa2dcf554f17d8d40f43fc" + }, + "Lean.Compiler.LCNF.Internalize": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Internalize.olean", + "sha256": "ddf26e1a280b6fcf208f46ca6683ffe8ef366527c447557a8852ba581abab6ff" + }, + "Lean.Compiler.LCNF.JoinPoints": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/JoinPoints.olean", + "sha256": "7955fd7fbf4caccbfc179059f5821358b5155dcce356bf20dbc5465989d12831" + }, + "Lean.Compiler.LCNF.LCtx": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/LCtx.olean", + "sha256": "798958fc2fdf1ff92063e6a5696a66dd32273a5eb6e04bfb217759105882742a" + }, + "Lean.Compiler.LCNF.LambdaLifting": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/LambdaLifting.olean", + "sha256": "16f7b519cd8548d6a88aff2c02029440110f13b2b009fb26afa4e8018d76f106" + }, + "Lean.Compiler.LCNF.Level": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Level.olean", + "sha256": "0ff39a4eec80e3c8047e926f4843c44eea5c1516e24c059c1c941d0948df7a6b" + }, + "Lean.Compiler.LCNF.Main": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Main.olean", + "sha256": "3678ef37331fb5a8b609a8ebfae188c589e87fef79ffff24533ea4059160f40c" + }, + "Lean.Compiler.LCNF.MonadScope": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/MonadScope.olean", + "sha256": "b16649d04910e51525f2513891c35417ccc791a9d19331355aea31cdbbe72a2e" + }, + "Lean.Compiler.LCNF.MonoTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/MonoTypes.olean", + "sha256": "6135eec86d64970beb3d9b00a2b74b30c0401784884cde565eefe186f42c7dac" + }, + "Lean.Compiler.LCNF.OtherDecl": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/OtherDecl.olean", + "sha256": "3cd7c6d125c8127901949761c55b36ebc963b7f28047fbb67221f978b966d0d0" + }, + "Lean.Compiler.LCNF.PassManager": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PassManager.olean", + "sha256": "0e7573909dd4940a95abface78fa3660072b1c6163a859562aec0e48c85451cf" + }, + "Lean.Compiler.LCNF.Passes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Passes.olean", + "sha256": "4b8864ccdfb3dabe28940e0e21f1726c3bbb252371c38e7992852f7da95ad0c9" + }, + "Lean.Compiler.LCNF.PhaseExt": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PhaseExt.olean", + "sha256": "8ed93f368be15928b930d48136cac9cac5eb283d269b53a4ccf9dc915480564c" + }, + "Lean.Compiler.LCNF.PrettyPrinter": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PrettyPrinter.olean", + "sha256": "484d0ba585c4943205d33a53df8d4735f52e7b4c65f9cc39a2dadece7e3ee769" + }, + "Lean.Compiler.LCNF.PullFunDecls": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PullFunDecls.olean", + "sha256": "20c18b55f55cc4cf61b95e3be8c6e2c2c1ce63af493e30d543534faf53550bc7" + }, + "Lean.Compiler.LCNF.PullLetDecls": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PullLetDecls.olean", + "sha256": "848f051bce9b922816355c97fc84232a03f85ed5fa38feed1b12ec6ff07eacac" + }, + "Lean.Compiler.LCNF.ReduceArity": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ReduceArity.olean", + "sha256": "bfb8fba4b4cf6829d092a9f3f4b5807108f7110296e6a9f71ceeb1f6ec90cd43" + }, + "Lean.Compiler.LCNF.ReduceJpArity": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ReduceJpArity.olean", + "sha256": "9bb32eeb3214ac55e1013ad425fd0c6852607391296751fddc2b8f4553f68c3e" + }, + "Lean.Compiler.LCNF.Renaming": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Renaming.olean", + "sha256": "bddac036add967291692acef307d3315af8aed4fd89a18d34311ac694ecf7816" + }, + "Lean.Compiler.LCNF.ScopeM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ScopeM.olean", + "sha256": "28822aa06f00730aba221eb7ae6cb264bb494bf25280246ffe6ff36c76243d28" + }, + "Lean.Compiler.LCNF.Simp": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp.olean", + "sha256": "58be16412a7c090265590410396a8263ede4d980f046637dff96f4a94d5d0b43" + }, + "Lean.Compiler.LCNF.Simp.Basic": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Basic.olean", + "sha256": "0bef1c90ca8bed6f80869aeb298d70671f82c7eec6f32e4576cca8d078d2ddfd" + }, + "Lean.Compiler.LCNF.Simp.Config": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Config.olean", + "sha256": "df3ec1bf55fe323c59d24d9e289dbb55b8e4e153686895cb4c6efbf33e693392" + }, + "Lean.Compiler.LCNF.Simp.ConstantFold": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/ConstantFold.olean", + "sha256": "63f240d9e408f7f34c53731a4b40b6784f639f7df3a130297aa52df6c5868ca3" + }, + "Lean.Compiler.LCNF.Simp.DefaultAlt": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.olean", + "sha256": "c7e68d37f1843b498489140e970e2caaa36548918cae5ddd881236065fdf9dfa" + }, + "Lean.Compiler.LCNF.Simp.DiscrM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/DiscrM.olean", + "sha256": "484a04366395e90ad0b5dd5c692a9e0da30c0918f50cca2ce7dc4459fbd6a590" + }, + "Lean.Compiler.LCNF.Simp.FunDeclInfo": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.olean", + "sha256": "63a8525abb01ee09dcd5fd7bb66fd5d5c9139ec98c9c4622594f19d042b7a81d" + }, + "Lean.Compiler.LCNF.Simp.InlineCandidate": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.olean", + "sha256": "04353a98d60a93bb13f644bc92b81233d665eff28f5e2594d7b7a45ef883572c" + }, + "Lean.Compiler.LCNF.Simp.InlineProj": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineProj.olean", + "sha256": "949390558396b4e92eb72823f8f123ce6a6a310b8e77234bd741d36a8158c1a4" + }, + "Lean.Compiler.LCNF.Simp.JpCases": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/JpCases.olean", + "sha256": "88b4036ff347ff9a1678d5eb585ca362ae0090e9de2b646e2efe90f4dc9a2328" + }, + "Lean.Compiler.LCNF.Simp.Main": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Main.olean", + "sha256": "0ae14b3273b7cb404efb46440a25ac0aaf8e49cd31eb57bea19b7833c219365b" + }, + "Lean.Compiler.LCNF.Simp.SimpM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpM.olean", + "sha256": "df1538b785d0aaa55d1d73ab4b63fd693959896c231a826d39818bddcb6b0d08" + }, + "Lean.Compiler.LCNF.Simp.SimpValue": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpValue.olean", + "sha256": "5de57ce90ffa7ba15734b33a8ad519ee98115c1e83f7ce047fcad5eb03bbe297" + }, + "Lean.Compiler.LCNF.Simp.Used": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Used.olean", + "sha256": "a4983d2052c84460309e9808f3d4518e65f78d7097eb707772abe71ba2bf5e4c" + }, + "Lean.Compiler.LCNF.SpecInfo": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/SpecInfo.olean", + "sha256": "4d9ce851163d5921bf6573eaf6b3d68442709f279fa96b23336b7b32d58a440b" + }, + "Lean.Compiler.LCNF.Specialize": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Specialize.olean", + "sha256": "9ecbcb6a200ec1984ed5231ba427a912a51177fbbfcf2d7ae584aba44397758b" + }, + "Lean.Compiler.LCNF.Testing": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Testing.olean", + "sha256": "8f082e72af8eb9e42eda181444b84c6a71e1a38e65b92e335abe9fda5f77d9cd" + }, + "Lean.Compiler.LCNF.ToDecl": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToDecl.olean", + "sha256": "edd9baf0d9dcc767a237f6ab3d3b8be89f5f7a8486579a61d92f3ee55c85ec8b" + }, + "Lean.Compiler.LCNF.ToExpr": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToExpr.olean", + "sha256": "97eb45572133529cfcd4d6581a8a27c406477191a1b027b7dbc8bbaf45bab62d" + }, + "Lean.Compiler.LCNF.ToLCNF": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToLCNF.olean", + "sha256": "3d2ca7cd028efcacaa2882570d10dd518c5a73860de6ceebb68658b3439607ab" + }, + "Lean.Compiler.LCNF.ToMono": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToMono.olean", + "sha256": "9c42901d6b7192fd65b8a5f809566805abc90063211569894835a17be53820b3" + }, + "Lean.Compiler.LCNF.Types": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Types.olean", + "sha256": "19db15eb19ec6842ff578614e85a7323642539fbb955b5912c170dec0eae2292" + }, + "Lean.Compiler.LCNF.Util": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Util.olean", + "sha256": "2a73fb99a3cb08e8a41425bc5ca182aaaa401508e583d6305a70868ea56208c3" + }, + "Lean.Compiler.Main": { + "relative_path": "lib/lean/Lean/Compiler/Main.olean", + "sha256": "9dc59f3522ff5c16389fc3454829050f7613c2f4175037beab5c0e4f86468de3" + }, + "Lean.Compiler.NameMangling": { + "relative_path": "lib/lean/Lean/Compiler/NameMangling.olean", + "sha256": "52aa954ea4c255de3c15968d309de875c4b03892e28568614f5b9e5d6bc3f38c" + }, + "Lean.Compiler.NeverExtractAttr": { + "relative_path": "lib/lean/Lean/Compiler/NeverExtractAttr.olean", + "sha256": "8efc3ead298e537a086cd425cfd99e6cd10185c78b13d8654d04435ed0f2c577" + }, + "Lean.Compiler.NoncomputableAttr": { + "relative_path": "lib/lean/Lean/Compiler/NoncomputableAttr.olean", + "sha256": "e396574927b99c247f101c8248a0a09cdff7a46e3809fb4589f0dcc4fba6d106" + }, + "Lean.Compiler.Old": { + "relative_path": "lib/lean/Lean/Compiler/Old.olean", + "sha256": "abc232855b58731d54ab07783fa46843208c6deace78b6b370cf476353c3e46d" + }, + "Lean.Compiler.Options": { + "relative_path": "lib/lean/Lean/Compiler/Options.olean", + "sha256": "b86376be11dc414b13c5a54d25cb7817f5660a01981e99d7f45f587f9a2933df" + }, + "Lean.Compiler.Specialize": { + "relative_path": "lib/lean/Lean/Compiler/Specialize.olean", + "sha256": "401294d22aa31d66ffea73cc8e81b84069c82bbf437abe562251e13bfd93394a" + }, + "Lean.CoreM": { + "relative_path": "lib/lean/Lean/CoreM.olean", + "sha256": "5e46337730d7e521a4ee2760c1adaea3e2862c5cc8006afed50f290ca2aafea7" + }, + "Lean.Data": { + "relative_path": "lib/lean/Lean/Data.olean", + "sha256": "3ea6fcf75dec1adae7990d5823a1527d3306689cb440e3c5ecea7b7ea7aab07d" + }, + "Lean.Data.Array": { + "relative_path": "lib/lean/Lean/Data/Array.olean", + "sha256": "d21870a1441bb3b382f82f64457d1fabeb8ab046e4147892433f89143f8481ea" + }, + "Lean.Data.AssocList": { + "relative_path": "lib/lean/Lean/Data/AssocList.olean", + "sha256": "9a08b7424a24c46dd2284b4c7b8692181a5e608302ae500e6445d627ea448d41" + }, + "Lean.Data.DeclarationRange": { + "relative_path": "lib/lean/Lean/Data/DeclarationRange.olean", + "sha256": "0c7a925cebc8a6c0405a7f6741afe5ecebca751b7141fc36518c902615167d6d" + }, + "Lean.Data.Format": { + "relative_path": "lib/lean/Lean/Data/Format.olean", + "sha256": "64c298e5e84c96a54830f2e1cf59e23ecd5c91c45336d9e99aa368884d8a9069" + }, + "Lean.Data.FuzzyMatching": { + "relative_path": "lib/lean/Lean/Data/FuzzyMatching.olean", + "sha256": "558ddc6d5ca38eada259e0fa5ad47478d15ba0f7878a7becb1c04394e7e98b19" + }, + "Lean.Data.Json": { + "relative_path": "lib/lean/Lean/Data/Json.olean", + "sha256": "3839c3f8868485cc28a91248414f8d7b15e3785cadd116d77d254f3acef1b768" + }, + "Lean.Data.Json.Basic": { + "relative_path": "lib/lean/Lean/Data/Json/Basic.olean", + "sha256": "d4a1599c4250412e05b960339e4898b1b5a9dde3f0292029eb02947f7df091cb" + }, + "Lean.Data.Json.Elab": { + "relative_path": "lib/lean/Lean/Data/Json/Elab.olean", + "sha256": "75bd0e3c0b0e50b6890616aff9499849bcc80f783737fb06762b1e638ce6641a" + }, + "Lean.Data.Json.FromToJson": { + "relative_path": "lib/lean/Lean/Data/Json/FromToJson.olean", + "sha256": "bc5266fe22b0d8289fac5e2194f2f3a5c0efa79dc538a96dee258041d8296066" + }, + "Lean.Data.Json.Parser": { + "relative_path": "lib/lean/Lean/Data/Json/Parser.olean", + "sha256": "eb9a4c2f421543848f9e21ff12b4cbf7ec42e0b339c4cc81725e9be627307a46" + }, + "Lean.Data.Json.Printer": { + "relative_path": "lib/lean/Lean/Data/Json/Printer.olean", + "sha256": "18bc6d83251888a60b8e091d5a7cd832d1733cca7cf8fc0afd197db2cd4bac6d" + }, + "Lean.Data.Json.Stream": { + "relative_path": "lib/lean/Lean/Data/Json/Stream.olean", + "sha256": "bbb7aea03b82669971dae676811dc7c4d2f91530d1b95dec8186faad10a2690e" + }, + "Lean.Data.JsonRpc": { + "relative_path": "lib/lean/Lean/Data/JsonRpc.olean", + "sha256": "324ae0dd9b94d607f0bd3634ff28ee91747e533225a1787ccffd3cdff6e78934" + }, + "Lean.Data.KVMap": { + "relative_path": "lib/lean/Lean/Data/KVMap.olean", + "sha256": "b69b36c839f87d7982c58dca02516af56a62b6e6f8cfed957727ab6fa5bdc3ac" + }, + "Lean.Data.LBool": { + "relative_path": "lib/lean/Lean/Data/LBool.olean", + "sha256": "e53d3d54cbdd02e971cade214336ed88039217dac49083fe9e2884774bc65980" + }, + "Lean.Data.LOption": { + "relative_path": "lib/lean/Lean/Data/LOption.olean", + "sha256": "ef57f5ca74f00d15e3353c7372bfd6539fad887f98eeb1405fc120f63fbc5450" + }, + "Lean.Data.Lsp": { + "relative_path": "lib/lean/Lean/Data/Lsp.olean", + "sha256": "5e8f95b054cf4f0bd78d09d3b60f8212677ebbcc9669810a4d555c12dbbe2c9d" + }, + "Lean.Data.Lsp.Basic": { + "relative_path": "lib/lean/Lean/Data/Lsp/Basic.olean", + "sha256": "10bd55152d2d3195bc716586b88ba354117a1610a511d4ef45e5bae4e47da591" + }, + "Lean.Data.Lsp.CancelParams": { + "relative_path": "lib/lean/Lean/Data/Lsp/CancelParams.olean", + "sha256": "34d5045104a2ad488db0eef5506fb5d152a50eb3b218963958249909e0693fc5" + }, + "Lean.Data.Lsp.Capabilities": { + "relative_path": "lib/lean/Lean/Data/Lsp/Capabilities.olean", + "sha256": "ea086554ff056336572f390c3a721392fc0a091b1e3ad5b11a1cbcfde01acb7d" + }, + "Lean.Data.Lsp.Client": { + "relative_path": "lib/lean/Lean/Data/Lsp/Client.olean", + "sha256": "66969eb1b65d7b7c0785a7410441db19c0684e49523b99141c98e9d6de265b1c" + }, + "Lean.Data.Lsp.CodeActions": { + "relative_path": "lib/lean/Lean/Data/Lsp/CodeActions.olean", + "sha256": "aaf6f59e076f612c399dc153b8655c630e5e8d3900d0c34e0754af24363fb5db" + }, + "Lean.Data.Lsp.Communication": { + "relative_path": "lib/lean/Lean/Data/Lsp/Communication.olean", + "sha256": "ff24b3db4d74dee7c02f3b312dfbcd8808ad401059a6e620467de85d2eae4b02" + }, + "Lean.Data.Lsp.Diagnostics": { + "relative_path": "lib/lean/Lean/Data/Lsp/Diagnostics.olean", + "sha256": "fab551e98e02150756f22d91f045edd2885311b0f2acd3b9f2518a03ac5315d1" + }, + "Lean.Data.Lsp.Extra": { + "relative_path": "lib/lean/Lean/Data/Lsp/Extra.olean", + "sha256": "328a92e6483fa971c03bc5c81df3fb8d54638f2b63589227cd51c150c184c6b3" + }, + "Lean.Data.Lsp.InitShutdown": { + "relative_path": "lib/lean/Lean/Data/Lsp/InitShutdown.olean", + "sha256": "6a4a2bdd2b9c291879021e2ac05ebb1766e5261b8eacce52931e0e3456e83582" + }, + "Lean.Data.Lsp.Internal": { + "relative_path": "lib/lean/Lean/Data/Lsp/Internal.olean", + "sha256": "7ac2bdcbc98918536b8dbc74f690ef33efa3d8f262d9da00b9745674124fa0f2" + }, + "Lean.Data.Lsp.Ipc": { + "relative_path": "lib/lean/Lean/Data/Lsp/Ipc.olean", + "sha256": "4655e8e87c7be2dee1388ddf2859e22126ff8e459049c7ae78b1f8c423523f60" + }, + "Lean.Data.Lsp.LanguageFeatures": { + "relative_path": "lib/lean/Lean/Data/Lsp/LanguageFeatures.olean", + "sha256": "9076799ae1e2a126180f4b65b4ba70bd0587000bbba075a49ede2e652940f648" + }, + "Lean.Data.Lsp.TextSync": { + "relative_path": "lib/lean/Lean/Data/Lsp/TextSync.olean", + "sha256": "661e837c6457b276db0fc3ff7b83c025daed1e81f1d119fa2bd8d8f703507212" + }, + "Lean.Data.Lsp.Utf16": { + "relative_path": "lib/lean/Lean/Data/Lsp/Utf16.olean", + "sha256": "3b966b6509a39ebdcfad59afb26a19c8b1ba431328424700a06d2f157e4628a2" + }, + "Lean.Data.Lsp.Window": { + "relative_path": "lib/lean/Lean/Data/Lsp/Window.olean", + "sha256": "80692ee76bcb8185fa3f79531823189b4aec6a02471db5978a0d41c260482632" + }, + "Lean.Data.Lsp.Workspace": { + "relative_path": "lib/lean/Lean/Data/Lsp/Workspace.olean", + "sha256": "9e2c734db08fbbf1a7eecf54afa2f4e6b2c4823fbfec4a700ca1ede9cbf099a8" + }, + "Lean.Data.Name": { + "relative_path": "lib/lean/Lean/Data/Name.olean", + "sha256": "608a86b16dc2e68888780aace6bf3c444be9ca982fbe05c0722b24a5941114cf" + }, + "Lean.Data.NameMap": { + "relative_path": "lib/lean/Lean/Data/NameMap.olean", + "sha256": "ad3950d1e39be7f250a74794819b4c299fd8aad0b95a8ebf383f713c4648667b" + }, + "Lean.Data.NameTrie": { + "relative_path": "lib/lean/Lean/Data/NameTrie.olean", + "sha256": "7b0032738d09c94b21eedfb74e920ce5781c864cc1541e28b9216f2296a3f50a" + }, + "Lean.Data.OpenDecl": { + "relative_path": "lib/lean/Lean/Data/OpenDecl.olean", + "sha256": "11d3c7dfac1707956e6ad5f8d99249971cefd2439d94b1042efcf1147a609848" + }, + "Lean.Data.Options": { + "relative_path": "lib/lean/Lean/Data/Options.olean", + "sha256": "69369d0818d266e890c00e318f186fdb767b308ec0ffa12c8d498ad8ab8dafd4" + }, + "Lean.Data.PersistentArray": { + "relative_path": "lib/lean/Lean/Data/PersistentArray.olean", + "sha256": "14912531f574091502391030308b9fe1d9d6751b946af2614e19472c009ed084" + }, + "Lean.Data.PersistentHashMap": { + "relative_path": "lib/lean/Lean/Data/PersistentHashMap.olean", + "sha256": "1eb926bd3f03db27a647b1dd1ae1606722f7f8bd555a8c9e4197e00d69af8819" + }, + "Lean.Data.PersistentHashSet": { + "relative_path": "lib/lean/Lean/Data/PersistentHashSet.olean", + "sha256": "bbe6fe443d42b01b3ee7c45908dd2761f3e0996e47c6d05531bfd326b82a1927" + }, + "Lean.Data.Position": { + "relative_path": "lib/lean/Lean/Data/Position.olean", + "sha256": "1031cb2dd0a833b50284a503a02c8f71490d93182219e9b2e43c536370992719" + }, + "Lean.Data.PrefixTree": { + "relative_path": "lib/lean/Lean/Data/PrefixTree.olean", + "sha256": "1cfc295f1fee5de8bb9c641f6c6a67ed4d24b3cea24af1b44ce8baae361860d7" + }, + "Lean.Data.RArray": { + "relative_path": "lib/lean/Lean/Data/RArray.olean", + "sha256": "6846f637e7f46e1ed281043406f082980d0db3c56fd1fc34fd080be3e743b11a" + }, + "Lean.Data.RBMap": { + "relative_path": "lib/lean/Lean/Data/RBMap.olean", + "sha256": "ecdafd26877ccf099c7ad634090493a314130ddb1f511402e869f833179f677a" + }, + "Lean.Data.RBTree": { + "relative_path": "lib/lean/Lean/Data/RBTree.olean", + "sha256": "4a1139cda04f91a7a78086a92cbfa53af7cd5ed0b04f50f388e91caba39e72c4" + }, + "Lean.Data.SMap": { + "relative_path": "lib/lean/Lean/Data/SMap.olean", + "sha256": "1af0bd0e0119f17204517f5b0e3ae76e582ad139d167e04d4b872c3b80fb9446" + }, + "Lean.Data.SSet": { + "relative_path": "lib/lean/Lean/Data/SSet.olean", + "sha256": "3ce020534c8de2eaaf8b72fdc30dfeff283d9fdf9cb402ee7eaa9d6e06bed49a" + }, + "Lean.Data.Trie": { + "relative_path": "lib/lean/Lean/Data/Trie.olean", + "sha256": "425b99d0861d274a027650fd85e91fe2ea4c8d2b332c26f05ce3faa69f8b22a9" + }, + "Lean.Data.Xml": { + "relative_path": "lib/lean/Lean/Data/Xml.olean", + "sha256": "3051520fc1f5e8969c97cd69b2e390cc0291e716af0304ca910917ca40c395b6" + }, + "Lean.Data.Xml.Basic": { + "relative_path": "lib/lean/Lean/Data/Xml/Basic.olean", + "sha256": "b78909fa2d132e4733174d2ce5edb87022889a3c00034a5600c37366d1249798" + }, + "Lean.Data.Xml.Parser": { + "relative_path": "lib/lean/Lean/Data/Xml/Parser.olean", + "sha256": "ef6845551edad3dd21f97bc12796643808c3e736f98ea92cd3836de8d120f896" + }, + "Lean.Declaration": { + "relative_path": "lib/lean/Lean/Declaration.olean", + "sha256": "34e3ddb2ffb4c62a725faaa32d867b47ce0f0e88e4d05b88cb4b0e8d06afcf14" + }, + "Lean.DeclarationRange": { + "relative_path": "lib/lean/Lean/DeclarationRange.olean", + "sha256": "0acae02702629cf9d8d1914af744e4616b1a11ec0c36b87b061ddb544de6c77f" + }, + "Lean.DocString": { + "relative_path": "lib/lean/Lean/DocString.olean", + "sha256": "a3acd1c0a67f2041105b56e4358104b944cccadaf6282f51d2d6c92c588e1322" + }, + "Lean.DocString.Add": { + "relative_path": "lib/lean/Lean/DocString/Add.olean", + "sha256": "4e2edfbc5d94f30cb22899dd904adf4e886c31d74a14b4867d5e6990ae6bef1f" + }, + "Lean.DocString.Extension": { + "relative_path": "lib/lean/Lean/DocString/Extension.olean", + "sha256": "62da3e2b1a78c1564bc55d7a62a3dd0bf3a5bb680c78b064545b34f22ff5f594" + }, + "Lean.DocString.Links": { + "relative_path": "lib/lean/Lean/DocString/Links.olean", + "sha256": "cb06ad02ed13e3becad26e41c65955dc450c95efd3c03c7e243480eb441a280e" + }, + "Lean.Elab": { + "relative_path": "lib/lean/Lean/Elab.olean", + "sha256": "fb002575329248f441db46568924da0347c0fc94899a897d260ed87e8b060d3a" + }, + "Lean.Elab.App": { + "relative_path": "lib/lean/Lean/Elab/App.olean", + "sha256": "7f2ef3399ca2be27e53f782db9299d1262626709416ecbde404d3044360c20e2" + }, + "Lean.Elab.Arg": { + "relative_path": "lib/lean/Lean/Elab/Arg.olean", + "sha256": "43fcac69dfb8c829f70e5c25b51a6864a5926de26a7f59d59b3434c77d2a4b70" + }, + "Lean.Elab.Attributes": { + "relative_path": "lib/lean/Lean/Elab/Attributes.olean", + "sha256": "a5a66de9739bb05ccb5303622d7e370cb631c209bade735a5a9263a16f2e994e" + }, + "Lean.Elab.AutoBound": { + "relative_path": "lib/lean/Lean/Elab/AutoBound.olean", + "sha256": "bf849b5b3131ab0c7cd465721e2bff12b3007ab05787e45d9c45cfe31dbcd8d9" + }, + "Lean.Elab.AuxDef": { + "relative_path": "lib/lean/Lean/Elab/AuxDef.olean", + "sha256": "a48e7422c13ae3730a198f9535a2a4f1d52af7ddff79a8e3e44f17e382bded85" + }, + "Lean.Elab.BinderPredicates": { + "relative_path": "lib/lean/Lean/Elab/BinderPredicates.olean", + "sha256": "f19b46d5afb2ed4f25501c99c971d43ef80056b1b54537acfab9b844b4baa033" + }, + "Lean.Elab.Binders": { + "relative_path": "lib/lean/Lean/Elab/Binders.olean", + "sha256": "5382842df889f912fcdc6829b4da03bccb31d24f644c9dc267d549a049f1f6e2" + }, + "Lean.Elab.BindersUtil": { + "relative_path": "lib/lean/Lean/Elab/BindersUtil.olean", + "sha256": "dab5459f96c9af7151e019d42c16f735587fe9d2e465680af5542694045d024e" + }, + "Lean.Elab.BuiltinCommand": { + "relative_path": "lib/lean/Lean/Elab/BuiltinCommand.olean", + "sha256": "e8873e484147230a2d52ed220e5d991242e27b35cb3e04ac44a121b4e60674e6" + }, + "Lean.Elab.BuiltinEvalCommand": { + "relative_path": "lib/lean/Lean/Elab/BuiltinEvalCommand.olean", + "sha256": "c9ffac4f0e2a910c88b947565e7186e7496b2bb71a51d3efa8b57df1716e2721" + }, + "Lean.Elab.BuiltinNotation": { + "relative_path": "lib/lean/Lean/Elab/BuiltinNotation.olean", + "sha256": "a8854418983a3521ac0009f1d1bc5886cbee99a420b5853c955e2bba669c8a01" + }, + "Lean.Elab.BuiltinTerm": { + "relative_path": "lib/lean/Lean/Elab/BuiltinTerm.olean", + "sha256": "d1c759f9d638631d8c7fcc61d904c4b3022e467c85374536404b62bcae94dbfa" + }, + "Lean.Elab.Calc": { + "relative_path": "lib/lean/Lean/Elab/Calc.olean", + "sha256": "517858cf70dbd5a3567f8c7efa08ebb072924f0ab475d1ea392d2d71f404a067" + }, + "Lean.Elab.CheckTactic": { + "relative_path": "lib/lean/Lean/Elab/CheckTactic.olean", + "sha256": "4ee79b7594813f45a0be34f47d7dcb9040038d236c08d62d075bb533cd209a06" + }, + "Lean.Elab.Command": { + "relative_path": "lib/lean/Lean/Elab/Command.olean", + "sha256": "d70527ba43f3a254e944e0951c798896a50306d8eb16d8caf346cc2c8de2037e" + }, + "Lean.Elab.ComputedFields": { + "relative_path": "lib/lean/Lean/Elab/ComputedFields.olean", + "sha256": "8aa833985762117070e65be8efd47e1105136cb60c5dce5bd1c3d9b777829778" + }, + "Lean.Elab.Config": { + "relative_path": "lib/lean/Lean/Elab/Config.olean", + "sha256": "ab8b7261941780805d87f6cd63432afa539d6810b16b3728dfa0be2722c36bd4" + }, + "Lean.Elab.DeclModifiers": { + "relative_path": "lib/lean/Lean/Elab/DeclModifiers.olean", + "sha256": "082924ed9a1233708427a204ac06d00058e16efc75a4fbf2b05260bd4b4d23d9" + }, + "Lean.Elab.DeclNameGen": { + "relative_path": "lib/lean/Lean/Elab/DeclNameGen.olean", + "sha256": "3074bf25442d70036c97fadd21d83594e0b375d89a203068ccdcfbd5ac0778ab" + }, + "Lean.Elab.DeclUtil": { + "relative_path": "lib/lean/Lean/Elab/DeclUtil.olean", + "sha256": "60ed8c5034fdb91d96f0d29a947ae510e6aa2d2c8144c82d941b33d8a236cef2" + }, + "Lean.Elab.Declaration": { + "relative_path": "lib/lean/Lean/Elab/Declaration.olean", + "sha256": "60127f7068dd6080656cc0b8fc28c04e2297a8c22ed96c5ebc6a940bb746f3d6" + }, + "Lean.Elab.DeclarationRange": { + "relative_path": "lib/lean/Lean/Elab/DeclarationRange.olean", + "sha256": "4f693d72400c7b0083dc440da6cd99962551af0a31fcdc5f23ad218b4c1cf9ba" + }, + "Lean.Elab.DefView": { + "relative_path": "lib/lean/Lean/Elab/DefView.olean", + "sha256": "4b0690fe469dcc04235e5f1db28aca28c0a1d1890622e846894836d8465cbe27" + }, + "Lean.Elab.Deriving": { + "relative_path": "lib/lean/Lean/Elab/Deriving.olean", + "sha256": "ce2343744dcd7113446dba7686175adce1b219cfa3e2a02b883dc96c83ba7492" + }, + "Lean.Elab.Deriving.BEq": { + "relative_path": "lib/lean/Lean/Elab/Deriving/BEq.olean", + "sha256": "9ee4fb8b5a18bc9a71a2188781679f93e6f7084d7166d0abca3348a2ea069748" + }, + "Lean.Elab.Deriving.Basic": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Basic.olean", + "sha256": "1ce625bec288e07f709d51fce4479fa7c90fa26229a535dbf101fb15f094b1f4" + }, + "Lean.Elab.Deriving.DecEq": { + "relative_path": "lib/lean/Lean/Elab/Deriving/DecEq.olean", + "sha256": "02f7fe725e01d8646ab570659983869355626c34eba194247edcef78ec767253" + }, + "Lean.Elab.Deriving.FromToJson": { + "relative_path": "lib/lean/Lean/Elab/Deriving/FromToJson.olean", + "sha256": "02247476a022d1f65eedd2bd2edc694bd4dad5f4766c175b99613a7f7573c7a8" + }, + "Lean.Elab.Deriving.Hashable": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Hashable.olean", + "sha256": "d6a8f5480a4d92cad91e38425026a73585933acdea29983327c6847c2b262f88" + }, + "Lean.Elab.Deriving.Inhabited": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Inhabited.olean", + "sha256": "39f9db1e14cd9748ee9fa5d6a892f8aea231b94d854d6b18d8386ef424f71e2d" + }, + "Lean.Elab.Deriving.Nonempty": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Nonempty.olean", + "sha256": "99cf8010b9439d9586ec46c94e4667b1a779478c343adeddb8744e3e9a40b8f6" + }, + "Lean.Elab.Deriving.Ord": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Ord.olean", + "sha256": "4a047b2d5dfcd783ad4004184a3752bd8a7ab07dd8a694e097d1d935e2935e9e" + }, + "Lean.Elab.Deriving.Repr": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Repr.olean", + "sha256": "6b3f39ea3a48df4fcdc3f54f23443e518331051c09c139e251e24e08830be248" + }, + "Lean.Elab.Deriving.SizeOf": { + "relative_path": "lib/lean/Lean/Elab/Deriving/SizeOf.olean", + "sha256": "e92edf4220bbfd45b65b0fec728a4e4d4cd94681b03bba266afa98e2615b9723" + }, + "Lean.Elab.Deriving.ToExpr": { + "relative_path": "lib/lean/Lean/Elab/Deriving/ToExpr.olean", + "sha256": "d6523a528599743a7df654f5743b1528f21614d72a44f3abe2aa8a28d3bd648d" + }, + "Lean.Elab.Deriving.TypeName": { + "relative_path": "lib/lean/Lean/Elab/Deriving/TypeName.olean", + "sha256": "c4792fb38b5aeb5ea5a62636aff5f757d361aa8efd4f18c67004aae538a459b7" + }, + "Lean.Elab.Deriving.Util": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Util.olean", + "sha256": "c12884adaa0c778910c1bb93eaed6108bdaea5154acf789cfade6ed2d07bc557" + }, + "Lean.Elab.Do": { + "relative_path": "lib/lean/Lean/Elab/Do.olean", + "sha256": "f7edfae85cb0c26decf417da2b632bd988396e64b591ed1e83d80007039803f3" + }, + "Lean.Elab.ElabRules": { + "relative_path": "lib/lean/Lean/Elab/ElabRules.olean", + "sha256": "f9382a01adb96c2df46c91c3b8f089161a092e303fa6c21f6ee11e052b6ff4a2" + }, + "Lean.Elab.Eval": { + "relative_path": "lib/lean/Lean/Elab/Eval.olean", + "sha256": "7c71d21984db41ed525d830c97c499f6b6bb94896b3ef708a3f0f3c3992816be" + }, + "Lean.Elab.Exception": { + "relative_path": "lib/lean/Lean/Elab/Exception.olean", + "sha256": "c1966d832888ab689c6fb710ec26064030ce9114979ba2be5b55438d3a588875" + }, + "Lean.Elab.Extra": { + "relative_path": "lib/lean/Lean/Elab/Extra.olean", + "sha256": "e04aa742507f1f8ce71235aee3e0410a0349afcce02af8033eda84793fd3cb07" + }, + "Lean.Elab.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Frontend.olean", + "sha256": "8a78aa55e40dc042d0ef7ee6eb0ac9a8e32e69499d416edbeaf41a87389bdfcc" + }, + "Lean.Elab.GenInjective": { + "relative_path": "lib/lean/Lean/Elab/GenInjective.olean", + "sha256": "71e9b7c42d5c7ba361b678074beaa897c5d59561f84b92e61be9bce93ba1516c" + }, + "Lean.Elab.GuardMsgs": { + "relative_path": "lib/lean/Lean/Elab/GuardMsgs.olean", + "sha256": "c31104fae5363b5f9b40b457899730f0bf09cb532dbdba7019768a491bfbe033" + }, + "Lean.Elab.Import": { + "relative_path": "lib/lean/Lean/Elab/Import.olean", + "sha256": "942d562b54b0f9c16191c1dc631a63c61242e662bb6b20a96c21aca07febd4a2" + }, + "Lean.Elab.Inductive": { + "relative_path": "lib/lean/Lean/Elab/Inductive.olean", + "sha256": "c0773865c8c9ed8cf8dd1799819033f043b272ece64a17dcfca9c393fc65d4d1" + }, + "Lean.Elab.InfoTree": { + "relative_path": "lib/lean/Lean/Elab/InfoTree.olean", + "sha256": "e70760b7a719b09450ee47e653758f4b04bf770d2540ecdad9c68e1ff9dcffb1" + }, + "Lean.Elab.InfoTree.InlayHints": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/InlayHints.olean", + "sha256": "9ba09f4498147935a7cc795b4dbeb9c50d057cf40bd69dc080cabcb53c6f528a" + }, + "Lean.Elab.InfoTree.Main": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/Main.olean", + "sha256": "1d24d8fe2cf5c200615e2441353a8f2ccb183bd92272ad1a91c143f037e59159" + }, + "Lean.Elab.InfoTree.Types": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/Types.olean", + "sha256": "f5ef787b574b053eb6c4dedb63628dcab9c3323860e03b9f1689b919f5a43ea6" + }, + "Lean.Elab.InfoTrees": { + "relative_path": "lib/lean/Lean/Elab/InfoTrees.olean", + "sha256": "6d9c5aef462dd3f15682d204244f1f309fe21ef6ef10afb72805a052e7360f97" + }, + "Lean.Elab.InheritDoc": { + "relative_path": "lib/lean/Lean/Elab/InheritDoc.olean", + "sha256": "13baf3bf2e721fe666937e96ef2e4c05b29802168cdbd1dbcb5024ff90c12808" + }, + "Lean.Elab.LetRec": { + "relative_path": "lib/lean/Lean/Elab/LetRec.olean", + "sha256": "25dedf0d0c914e81ba7d5f40d8cac33b777717b8587e668add128fd532e0a129" + }, + "Lean.Elab.Level": { + "relative_path": "lib/lean/Lean/Elab/Level.olean", + "sha256": "6a2e73a7585f6edbc7aa991ced908c75f6a0b6677c602f9688c2187f4e424507" + }, + "Lean.Elab.Macro": { + "relative_path": "lib/lean/Lean/Elab/Macro.olean", + "sha256": "6d4ddaaad390cc33240dabfe92351ce1b4475bc00e2bfc13a1e7d1275b731e9c" + }, + "Lean.Elab.MacroArgUtil": { + "relative_path": "lib/lean/Lean/Elab/MacroArgUtil.olean", + "sha256": "66055bb8c852b726c6c019c0ea30d9680da2b79d0f7281bae9dd6aac4e69c745" + }, + "Lean.Elab.MacroRules": { + "relative_path": "lib/lean/Lean/Elab/MacroRules.olean", + "sha256": "87258a9723089efebfd06f4fd21de2d60819043181f411caf52db4e4d61c9269" + }, + "Lean.Elab.Match": { + "relative_path": "lib/lean/Lean/Elab/Match.olean", + "sha256": "f96ca7fa6ad4572f2e70f9caf0017d6b703f6343f966146652b6a4567e075ecb" + }, + "Lean.Elab.MatchAltView": { + "relative_path": "lib/lean/Lean/Elab/MatchAltView.olean", + "sha256": "bcc410a60ab916611cd1314ccb349d1e6291534e2f54f1acc879ae5dd92e127e" + }, + "Lean.Elab.MatchExpr": { + "relative_path": "lib/lean/Lean/Elab/MatchExpr.olean", + "sha256": "c4a41299da81eb484f5ed9c1f11a2ea202f408aedd6f89eec668ec2309a05668" + }, + "Lean.Elab.Mixfix": { + "relative_path": "lib/lean/Lean/Elab/Mixfix.olean", + "sha256": "9a948b85420661584f24c9c1adb6e9de9d89e53b1c9a71f91ebc0c27b7664c6b" + }, + "Lean.Elab.MutualDef": { + "relative_path": "lib/lean/Lean/Elab/MutualDef.olean", + "sha256": "1f9b71fb58473a9ed15668ce35710aadb27f433aa3d403cb989ae40f4f22c468" + }, + "Lean.Elab.MutualInductive": { + "relative_path": "lib/lean/Lean/Elab/MutualInductive.olean", + "sha256": "cadab2c90a0b83ef83df3405057155eceeb5335b3496f9f380677d08a5d03cf0" + }, + "Lean.Elab.Notation": { + "relative_path": "lib/lean/Lean/Elab/Notation.olean", + "sha256": "48412518cf3a658eae49c64cc1467c82b71bc9d8210744b25af28f2c920335ed" + }, + "Lean.Elab.Open": { + "relative_path": "lib/lean/Lean/Elab/Open.olean", + "sha256": "871d01b5e8a7d02623aae31186f1d6440de1e88cfa5a61aa65d49bc339b801b1" + }, + "Lean.Elab.ParseImportsFast": { + "relative_path": "lib/lean/Lean/Elab/ParseImportsFast.olean", + "sha256": "e7c263fcce8f9f845a93cbacd4270d29f526c6f49542bfd3fabda67b7bf6a78a" + }, + "Lean.Elab.PatternVar": { + "relative_path": "lib/lean/Lean/Elab/PatternVar.olean", + "sha256": "cc24f76e8a73bb74fa086ffc0ca15b83727e9fe862a2bebeb5ef951d328568ec" + }, + "Lean.Elab.PreDefinition": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition.olean", + "sha256": "cf08e93464411219890b4cb1bab8e1610a70a4fb65e43b50bd739539ef367547" + }, + "Lean.Elab.PreDefinition.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Basic.olean", + "sha256": "e37a918d0df8abd0297fe32ffe904d12705e71a5098c0c3299788bec711135d8" + }, + "Lean.Elab.PreDefinition.EqUnfold": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/EqUnfold.olean", + "sha256": "3461b20ecf2a82f12d463ada0c8741fa66ee5d67ad1f6baf6e744166ccecb007" + }, + "Lean.Elab.PreDefinition.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Eqns.olean", + "sha256": "19c4d86d1bc0cb30d41db8fee326500bff23ce73f35d422a577d118a346c3f4c" + }, + "Lean.Elab.PreDefinition.FixedParams": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/FixedParams.olean", + "sha256": "0b2ab92716760dec18c20cef92a923f45ced48471005b89968dc44cc042a7787" + }, + "Lean.Elab.PreDefinition.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Main.olean", + "sha256": "e9da272ef4937c5dea929555f1afb9c0bc5e546c46ba077dba6ecad53fc039f9" + }, + "Lean.Elab.PreDefinition.MkInhabitant": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/MkInhabitant.olean", + "sha256": "01386a0e9abb41906ebeff2b51300a35bdb976fd8f5414996e90edbe7aa71535" + }, + "Lean.Elab.PreDefinition.Mutual": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Mutual.olean", + "sha256": "7727402f03f91af4db7349660aa7d8ea7512be3c6a5a9745e4528df91b2d86e2" + }, + "Lean.Elab.PreDefinition.Nonrec.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.olean", + "sha256": "3651d817386974e312357f20f0f5b695df32636b45ad87bf257e12333522f7de" + }, + "Lean.Elab.PreDefinition.PartialFixpoint": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint.olean", + "sha256": "e66825e384ff17dc6519d4c3bbb1e2d437fb9d06ccd62c25ae39462160bb8a74" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.olean", + "sha256": "dfaf14ede280a406724d7388dfd50253eb1f72bc95053c73e5b5ec562eb13181" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Induction": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.olean", + "sha256": "ace8bf806b6e3c115ca8dca8903b2590944121d6ee15b166a9e90d26f8c65de2" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.olean", + "sha256": "ce6f69f8a60fbf4529c56fb9d180b9848c4dc94b0924669d52edadea1eea85da" + }, + "Lean.Elab.PreDefinition.Structural": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural.olean", + "sha256": "5df5e860a2941222d125302b6992dfee99076a8dfe7635e03d0067b1de52037b" + }, + "Lean.Elab.PreDefinition.Structural.BRecOn": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/BRecOn.olean", + "sha256": "43d778c2e31237bab4927df047f983f90d8e51f0c8994766eade48f3cf6ac721" + }, + "Lean.Elab.PreDefinition.Structural.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Basic.olean", + "sha256": "b9c232de8b46027f3e53de76dcd73a120fe39c3d59967a5a5d4b770687546ff6" + }, + "Lean.Elab.PreDefinition.Structural.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Eqns.olean", + "sha256": "1ab842d0ec3f072b7ef36c3c389106b6281772e9c39077183524e8a7b2df26d4" + }, + "Lean.Elab.PreDefinition.Structural.FindRecArg": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.olean", + "sha256": "22c836971360cfbae10b952afc57c8cceea7c6e0776bc4f5785db9f56231f4dc" + }, + "Lean.Elab.PreDefinition.Structural.IndGroupInfo": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.olean", + "sha256": "bcbc74eedc2f318a8b2b3f67dee27bbad4499edf1b90e1b5ef2f97392829471e" + }, + "Lean.Elab.PreDefinition.Structural.IndPred": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndPred.olean", + "sha256": "933c5f3adb300c234bc4b21c33ac88720ce348df0da6101f5e29e82e2c9ebd09" + }, + "Lean.Elab.PreDefinition.Structural.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Main.olean", + "sha256": "c4239a1efe6ae90a63a33c58a2a4416ad6811c5b137a4fff5e14dea0c97dbf4e" + }, + "Lean.Elab.PreDefinition.Structural.Preprocess": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Preprocess.olean", + "sha256": "da41c20561ffeedc9fa735b40812cfc6f2019cb4ae039fcc9b50bdb3c4b42beb" + }, + "Lean.Elab.PreDefinition.Structural.RecArgInfo": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.olean", + "sha256": "374c899afb685ea073722e49bbec2c586e1a3f301580147f1092dce75749f0e9" + }, + "Lean.Elab.PreDefinition.Structural.SmartUnfolding": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.olean", + "sha256": "a3bb8c3544d361c4654090f576b2f089aca1931220817eadc9e6fde12d8d2e84" + }, + "Lean.Elab.PreDefinition.TerminationHint": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/TerminationHint.olean", + "sha256": "b008cd03dae9e9eb39f7c961783c7688bb0079c86b3380e5a2acba0931c96912" + }, + "Lean.Elab.PreDefinition.TerminationMeasure": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/TerminationMeasure.olean", + "sha256": "7b6a83a24610cdb1a23a9e279cc4e2490f0984dc226172227a54b14653bc04b5" + }, + "Lean.Elab.PreDefinition.WF": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF.olean", + "sha256": "d756a42673113d104a8f1f10ec8e5266fd550ab3307d74635cff1a79dfdf50ee" + }, + "Lean.Elab.PreDefinition.WF.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Basic.olean", + "sha256": "30e303f01dd11f5bfb9bfe9f0ac7281cb267c79ee600883e9b75ec7ef3269c4a" + }, + "Lean.Elab.PreDefinition.WF.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Eqns.olean", + "sha256": "cbcee84f0b521613f3b81a830c4672dcec0ec776d61e47ac8e8a6b323e9d8dda" + }, + "Lean.Elab.PreDefinition.WF.Fix": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Fix.olean", + "sha256": "1cd3b02dd48b1739fbdd069bca0f18019590476d52d0b55f770483952212ed4c" + }, + "Lean.Elab.PreDefinition.WF.FloatRecApp": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.olean", + "sha256": "2b2b7508f7f5f71d39f30b406dc2b24879727bee44615b1eabe341e1df9438e1" + }, + "Lean.Elab.PreDefinition.WF.GuessLex": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/GuessLex.olean", + "sha256": "193a0f7bb3f60de6c3af28362ca4e34e9e5812f17dc23e55e448a949992f31df" + }, + "Lean.Elab.PreDefinition.WF.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Main.olean", + "sha256": "f877b579eeead916865fd609fde94addce79bb845e0d983e5733a88485a5766c" + }, + "Lean.Elab.PreDefinition.WF.PackMutual": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/PackMutual.olean", + "sha256": "2a5db58f9cf338b84db997411fc33bfe8e86284d92310df8c5de6e0b4319267f" + }, + "Lean.Elab.PreDefinition.WF.Preprocess": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Preprocess.olean", + "sha256": "1c2bd7a90e2254ed6d603023a49e6171f7c0d9a14b5516b28a4c216f5006fea9" + }, + "Lean.Elab.PreDefinition.WF.Rel": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Rel.olean", + "sha256": "c5bc9c3e5ac6b953c20efa66eb36629b6b957e1b043e34c4bc970e0c86aa0c11" + }, + "Lean.Elab.PreDefinition.WF.Unfold": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Unfold.olean", + "sha256": "e6f3e0b9a8ac077b6329df9ed9c09f78cd31e02841a3511420ee8e65d226bbe6" + }, + "Lean.Elab.Print": { + "relative_path": "lib/lean/Lean/Elab/Print.olean", + "sha256": "51e5f29b3d8074b0a7162eff78b664217a5dbc27efb76b145dbaea0c05c34a96" + }, + "Lean.Elab.Quotation": { + "relative_path": "lib/lean/Lean/Elab/Quotation.olean", + "sha256": "71b2f7b722ffcaeb09b2708d6bc5d6ff5cf1c17b12376699ea36d61f4b422eed" + }, + "Lean.Elab.Quotation.Precheck": { + "relative_path": "lib/lean/Lean/Elab/Quotation/Precheck.olean", + "sha256": "991a462e6701ed3ac0da579a5f9f2c7f7f666f3c9841eda19c86bb9576108653" + }, + "Lean.Elab.Quotation.Util": { + "relative_path": "lib/lean/Lean/Elab/Quotation/Util.olean", + "sha256": "f1eb03e06f604ef25245d13da5f6e5884e335fbb462b85cc25d2fddb1799a7fd" + }, + "Lean.Elab.RecAppSyntax": { + "relative_path": "lib/lean/Lean/Elab/RecAppSyntax.olean", + "sha256": "6abcf436c2719a2ec1d8bd634b141bc3276d0bf3e27e3cf005ea336fc9663bb7" + }, + "Lean.Elab.RecommendedSpelling": { + "relative_path": "lib/lean/Lean/Elab/RecommendedSpelling.olean", + "sha256": "9661fccfded1a3c1cfa6fd6ffb7d563b2884d98e4e644ab18eca9200cbebfab6" + }, + "Lean.Elab.SetOption": { + "relative_path": "lib/lean/Lean/Elab/SetOption.olean", + "sha256": "787c484587500ec3158e59ca10eebfea0af7d3083806a9471891821f6495a64d" + }, + "Lean.Elab.StructInst": { + "relative_path": "lib/lean/Lean/Elab/StructInst.olean", + "sha256": "47bb7c2c4610c8d54accb1bd6542626bb9d4b08e731135120c54cc9b9952abec" + }, + "Lean.Elab.Structure": { + "relative_path": "lib/lean/Lean/Elab/Structure.olean", + "sha256": "156b1283480708d45f2d4ccb21165c157b65fafa79490d678b5b221e6ee0b44e" + }, + "Lean.Elab.Syntax": { + "relative_path": "lib/lean/Lean/Elab/Syntax.olean", + "sha256": "6aad81137b009aa764c5d98639ee5fb600f0ce6fc27cdef1e073588a4c223986" + }, + "Lean.Elab.SyntheticMVars": { + "relative_path": "lib/lean/Lean/Elab/SyntheticMVars.olean", + "sha256": "765f17386784a6540f899b2af62be08e7b576a00a78f41584973b8fabf27d621" + }, + "Lean.Elab.Tactic": { + "relative_path": "lib/lean/Lean/Elab/Tactic.olean", + "sha256": "a8372c1c69001269930b6cbb4e881b9e8b593ac0d594e93ec7e6d361eaf3c368" + }, + "Lean.Elab.Tactic.AsAuxLemma": { + "relative_path": "lib/lean/Lean/Elab/Tactic/AsAuxLemma.olean", + "sha256": "3ab8861debb8b53d853057c0c66642079e60144679861402226630668939e906" + }, + "Lean.Elab.Tactic.BVDecide": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide.olean", + "sha256": "6736cf5da5943762151cf22c1342fc178f0f295bee9aeb7cf004c317aa45a07d" + }, + "Lean.Elab.Tactic.BVDecide.External": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/External.olean", + "sha256": "50fecaf48258db97412a2cafd593773db1dfa2339c681a31a4102f808b7a1327" + }, + "Lean.Elab.Tactic.BVDecide.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend.olean", + "sha256": "1336b674c40caf3ba24bb63e4b78ac58dee96d925c2fcc3036283109aaf823d0" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Attr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.olean", + "sha256": "7a316bf1617de928f47afdd80f6ca28befae2fe6ad6b96dac4b7e290360f579b" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVCheck": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.olean", + "sha256": "75b4d47160ec998fe08da4884247a1cea961fad7e19bf6357670f6f626d5f036" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.olean", + "sha256": "6557c91e5d2a05ba4a56c820828531dab370c1809771585e49a7b96a9a40ac75" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.olean", + "sha256": "2b22721a88841e65d1256e7d6b3a7132b26ff1197f1ca65e3be5a5eb21422d49" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.olean", + "sha256": "7f79411de643ca37c169708a76aa12321701070ad666f41c243b1c6df2f52e07" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.olean", + "sha256": "3fa0a32b34699ba1f97db7c29be8d8b88b47c47e52de12f6191d5e6327c613b4" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.olean", + "sha256": "a04f49452a90cab257db038fe0025d6e9b9f72ee3313a479b99fcac4ae1c8f13" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.olean", + "sha256": "6c4ff9969869b0ba86b098d8bb95e2caeb88bc61426a7659ec2d1e80fd3f0496" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.olean", + "sha256": "65491bfa39b0698c310a8a8878cb01596e4616627416f40ae45e0fd622709e54" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.olean", + "sha256": "980164e9c31b64c83e46c01e78ec64630226c39920485143be4e40b859da161e" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVTrace": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.olean", + "sha256": "1996eabaa1c3f4916f484b35c39a4bcc270e9a46b9592b9b6e63b28b95acd5fa" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.LRAT": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.olean", + "sha256": "a9777f4dc66bea0b57d7a9b2b750ce78d906d0bfa930cfd0b0281b5920467aba" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.olean", + "sha256": "74af1f202de4c2fbe0aeab11e5bf05bb495342404062a0db74097f35b666b423" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.olean", + "sha256": "b24d88b0fbed216dfdaf934f8653d37291af5e1288d5485736bfd75deb10c182" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.olean", + "sha256": "df98785c5e1b7e6e5114b0c1a90760ee11277742f3ec36f4834cafa51fc567a1" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.olean", + "sha256": "8abb3b652bdd68df142259c20a7e85e26fc1c7f1ad5d1111ad8574cb7251323f" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.olean", + "sha256": "07d568115382b9a9832437443a5665dd9ab05ebaaa6e613e2336083a18a5f843" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.olean", + "sha256": "5a338a9edef0294acf2e8ee6923e0b02965595576fff7b130ced1626af66fdc6" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.olean", + "sha256": "b999e4ddc8d0d2077c56af1f1a000fe53fa3e81c97b47c5bf48d4dfbc243cfd8" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.olean", + "sha256": "82d5b4e7c2ec35f28230ce0ea464680a38a439260496c2ecc624130c7177a14b" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.olean", + "sha256": "bf6a3b70f9fedd5c42111b2afd4a947fc8085947342a1123073f65558540f436" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.olean", + "sha256": "a6588498df687fb758121463de9ae1040535ceb6c317715218669e061b05a088" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.olean", + "sha256": "87a5d15e22301b1a7c50064a06e11cae3e2b3b7ae8f4db72437bd5dea8d09077" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.olean", + "sha256": "7e18d7f9c1daff3a8b7eeca9765a3933fb244156bb5a238b03fd3d6667146a57" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.olean", + "sha256": "a60b02e2a039134f7b533c911f7beed13d84812b6062b9f19185630e282912ce" + }, + "Lean.Elab.Tactic.BVDecide.LRAT": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT.olean", + "sha256": "2265489cbaad7404d01662160bc49c6036f770a8a23257ad912587b3c94c992f" + }, + "Lean.Elab.Tactic.BVDecide.LRAT.Trim": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.olean", + "sha256": "496f7c3dd081cece59390406bd9ca3d7b8280aa923e7d50e764867b0f3895546" + }, + "Lean.Elab.Tactic.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Basic.olean", + "sha256": "b7c0301d5608f70cc3b200a6c051173f74f9feffb83b1e7993b680a28e4dec4f" + }, + "Lean.Elab.Tactic.BoolToPropSimps": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BoolToPropSimps.olean", + "sha256": "d5e4ca3bfddbd7e2538e80f41161ea63be1ed1eec0bd637d064b11e4478c6737" + }, + "Lean.Elab.Tactic.BuiltinTactic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BuiltinTactic.olean", + "sha256": "72d1c873432fe4f9dff0aa9a83056dd824703fe0faa8593f5e2a186335e12c21" + }, + "Lean.Elab.Tactic.Calc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Calc.olean", + "sha256": "b22ed20091a768b533dbf3cb92b94e3dea2a22cc70e6e013bc0e932c0a92d721" + }, + "Lean.Elab.Tactic.Change": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Change.olean", + "sha256": "c3d3fe5640183577289c4f0c7dfc9a5e82953709dc9f81ab3305a64f2c972f83" + }, + "Lean.Elab.Tactic.Classical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Classical.olean", + "sha256": "dd96a577b5982c72e7c2f9cce5cf089a933ecc0614589fdd0d741b39c721b9d5" + }, + "Lean.Elab.Tactic.Config": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Config.olean", + "sha256": "18f6104d6c843452c5742a476d16659ee05d21021eefd2d72d3a9be27a4c0009" + }, + "Lean.Elab.Tactic.Congr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Congr.olean", + "sha256": "c2cbd01a116eeab3bc6d560d5b5e812915eda68ddd4fd972444df910e1ce6f07" + }, + "Lean.Elab.Tactic.Conv": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv.olean", + "sha256": "9e13c60aac36d8d5ab077fb214f9749bd03e689fd47b66fdeb65f54b42e61fcc" + }, + "Lean.Elab.Tactic.Conv.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Basic.olean", + "sha256": "36acbc413b0baecc6d1db794fdf6e9afdc393dbb0a43b4d132ed06e80af8987d" + }, + "Lean.Elab.Tactic.Conv.Change": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Change.olean", + "sha256": "d6645dd05e52922f9008332cc16dffd5e475221c524292446010a022f7180efc" + }, + "Lean.Elab.Tactic.Conv.Congr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Congr.olean", + "sha256": "b5c476623ea1b622800815da4f1d2b769643c1bdb0c4c7524bed4851276413bf" + }, + "Lean.Elab.Tactic.Conv.Delta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Delta.olean", + "sha256": "6953c32bc540eaaa79b2221b31a9eecf9d86fc5ce46e69cc8f0ad6a3f1902419" + }, + "Lean.Elab.Tactic.Conv.Pattern": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Pattern.olean", + "sha256": "8fae7911921a66098eba444b60030314b9f52f202353e586205472afdd07c068" + }, + "Lean.Elab.Tactic.Conv.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Rewrite.olean", + "sha256": "492425f642d76075007692216a7368c533ebb8e0def54334a7fbbe849baed77e" + }, + "Lean.Elab.Tactic.Conv.Simp": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Simp.olean", + "sha256": "914f50cab77467b8faa5d21c14664fa552ca6c69339ecfc798150b48b37d3272" + }, + "Lean.Elab.Tactic.Conv.Unfold": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Unfold.olean", + "sha256": "a893adf2f22bb0bae62f47d5c4b30ae3bcedc121a7ab747398e5f780262be63b" + }, + "Lean.Elab.Tactic.Delta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Delta.olean", + "sha256": "c80c125f4b2c716c5a140a18b02d0c2c2add3d4a4e749e9774b6e36a6e6d726f" + }, + "Lean.Elab.Tactic.DiscrTreeKey": { + "relative_path": "lib/lean/Lean/Elab/Tactic/DiscrTreeKey.olean", + "sha256": "90696c26393713d01d2efefc91713c23de2d2b9ea842dcd5b0be7602ef2d2d51" + }, + "Lean.Elab.Tactic.Doc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Doc.olean", + "sha256": "f7466ce696081046b90259ed10bfce6647f3e31b5b624987527aace912d6836d" + }, + "Lean.Elab.Tactic.ElabTerm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ElabTerm.olean", + "sha256": "c93025d17c141b6a8172abd80d25fd2083f061aea574ed5b5fb85752f32ef39f" + }, + "Lean.Elab.Tactic.ExposeNames": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ExposeNames.olean", + "sha256": "b5083e8a6aa77fd5d2aa2a73cdd0777e2f2e7018e6fe73f017e31220f136ab36" + }, + "Lean.Elab.Tactic.Ext": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Ext.olean", + "sha256": "41b7e7b7c44fec4c25d21754296cb2c63b901f6ec840e4d68fd5f73c0d27bf16" + }, + "Lean.Elab.Tactic.FalseOrByContra": { + "relative_path": "lib/lean/Lean/Elab/Tactic/FalseOrByContra.olean", + "sha256": "e9c4388c61790ea040377ad4794524db4078ac279c84bfda4873f93a9e286e72" + }, + "Lean.Elab.Tactic.Generalize": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Generalize.olean", + "sha256": "f508333fab3030de8fd72a5d3e269baab671664d61c9a4f9d838a86a49945533" + }, + "Lean.Elab.Tactic.Grind": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Grind.olean", + "sha256": "08be616fb5e448a7109ff7ea58dd14de1902dbe5e8df8a873ba79e4e34523c74" + }, + "Lean.Elab.Tactic.Guard": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Guard.olean", + "sha256": "f853574192c0c04c7a6fd40a04e71966bea87d164c2dfd58066119d2b273cc53" + }, + "Lean.Elab.Tactic.Induction": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Induction.olean", + "sha256": "cb71a7fa68a672ebb2f3bfa1643a418d82d0c545d5d5b2e992a46695a14f491e" + }, + "Lean.Elab.Tactic.Injection": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Injection.olean", + "sha256": "a21d54f553d5ecbeb0bb2983f5d37040186dca297ccaa8fe5457c15333f55662" + }, + "Lean.Elab.Tactic.LibrarySearch": { + "relative_path": "lib/lean/Lean/Elab/Tactic/LibrarySearch.olean", + "sha256": "aa4345322004c2831a322f51f0b28e6c846017c08fe3dc2861c6497dca393055" + }, + "Lean.Elab.Tactic.Location": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Location.olean", + "sha256": "1098b443df5ebadfee2fc68faf7038dabacb07541f38639ac31be344e1391bdf" + }, + "Lean.Elab.Tactic.Match": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Match.olean", + "sha256": "63335a98a881cb68e20bffdb30fa3771ecb62823849ae21bb31426adc5aaccc9" + }, + "Lean.Elab.Tactic.Meta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Meta.olean", + "sha256": "567713a64ca01f5b9ab6c091ed9cd25f3ae811dd96d379690824c1048238a466" + }, + "Lean.Elab.Tactic.Monotonicity": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Monotonicity.olean", + "sha256": "fa4e39f81c52c25684740ec8b522ddb1e75e2a770da086aa498542a0254bb3ab" + }, + "Lean.Elab.Tactic.NormCast": { + "relative_path": "lib/lean/Lean/Elab/Tactic/NormCast.olean", + "sha256": "8edb153050da1e5977675c29d0faa559f8ede051b8384ea592aa05c9c892e10d" + }, + "Lean.Elab.Tactic.Omega": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega.olean", + "sha256": "4b2613345cb64b57ac4f8a0183f43e1afe4138ef8eaed2158e9d053107262491" + }, + "Lean.Elab.Tactic.Omega.Core": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/Core.olean", + "sha256": "f133556a6f4675885619fb6fb25a670fb3afce9a98b14ab0b31d89b5ecb6a2ea" + }, + "Lean.Elab.Tactic.Omega.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/Frontend.olean", + "sha256": "03c91bedf7a6187e5e74519f66bda5d6e18552fa291f950f9d3310613d99013d" + }, + "Lean.Elab.Tactic.Omega.MinNatAbs": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/MinNatAbs.olean", + "sha256": "5fc208621322f361f7d3e75f63418aec5d8851c6b75bd6a39e922f0d8b0ba191" + }, + "Lean.Elab.Tactic.Omega.OmegaM": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/OmegaM.olean", + "sha256": "99de653d54903f4599f5883f5fc1fb078ca24550ff5656b10ff227552f8af2b8" + }, + "Lean.Elab.Tactic.RCases": { + "relative_path": "lib/lean/Lean/Elab/Tactic/RCases.olean", + "sha256": "cb15fe0c2bb64023666293bb14cd157c6d756fa59dc0e8aec39b8b6f28968731" + }, + "Lean.Elab.Tactic.Repeat": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Repeat.olean", + "sha256": "5f1389c2109470e537d2486218baea2f9b69842ad86150b3c78d919b589020b5" + }, + "Lean.Elab.Tactic.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rewrite.olean", + "sha256": "332ab3fca4f37076f27bbdf57e5d614923d0d1048e1e325c56a4ae5f78a3bdf0" + }, + "Lean.Elab.Tactic.Rewrites": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rewrites.olean", + "sha256": "510a661f998f5c279f14b60fec476368bb1ed9a003c3c4753c6caa2d88c349c1" + }, + "Lean.Elab.Tactic.Rfl": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rfl.olean", + "sha256": "debc83c10ccd0f91e6944c7f2409f0390766d3c90195d90b9bc3e379a5528ebf" + }, + "Lean.Elab.Tactic.ShowTerm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ShowTerm.olean", + "sha256": "1a58d3dab98f084c1e30cd1ad363f9dcce132dd3563f7f1b3a10ea4e5b982b31" + }, + "Lean.Elab.Tactic.Simp": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simp.olean", + "sha256": "7c99ed2d7fd716baaff7454c392df88cc0ed62c7717f7a3df5fde04e69b76a24" + }, + "Lean.Elab.Tactic.SimpArith": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SimpArith.olean", + "sha256": "947ba620a7f12f3039363f12e8b609b1532421e0a15de3091c7476f38200cd19" + }, + "Lean.Elab.Tactic.SimpTrace": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SimpTrace.olean", + "sha256": "71135cbb56c87c91b4654fc258dfee3c56abd5659705c75502c97bc4098f2b1b" + }, + "Lean.Elab.Tactic.Simpa": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simpa.olean", + "sha256": "ecf16470fb1388ccc43ef450a7cc9a3bea94c691d800f90b909817b14d277db2" + }, + "Lean.Elab.Tactic.Simproc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simproc.olean", + "sha256": "67adccf068a87d29a3658b600ea8d395ad93eb34518f94930e273e9dd227a998" + }, + "Lean.Elab.Tactic.SolveByElim": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SolveByElim.olean", + "sha256": "4b83ef14834e716e40e4225b7fc6e6e0be6a4fac044490fcdcea8684314e9890" + }, + "Lean.Elab.Tactic.Split": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Split.olean", + "sha256": "1d662891823face6895782eadc704cb76813e37325f70c681ac2e481219d06a2" + }, + "Lean.Elab.Tactic.Symm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Symm.olean", + "sha256": "03415c9848515aa79dac3634eda5a005dbe2d662168206bdae2d4aeebbc5c670" + }, + "Lean.Elab.Tactic.TreeTacAttr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/TreeTacAttr.olean", + "sha256": "317645bd9832a71c3d83747c516f0084c6f778a2f01a9f1725396a9ee99f9405" + }, + "Lean.Elab.Tactic.Try": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Try.olean", + "sha256": "e06377c171ef6f8d33196b70e2c138672956f14a668924bd8dbba6ede2325966" + }, + "Lean.Elab.Tactic.Unfold": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Unfold.olean", + "sha256": "a096a399bfc253d22fceda76ad31bfe1c32923302d3fc517e0736b8c2e29fb74" + }, + "Lean.Elab.Term": { + "relative_path": "lib/lean/Lean/Elab/Term.olean", + "sha256": "f96c6c457c651da44cb9aed7d0af002589a9dd635ec492029254eeb679e85703" + }, + "Lean.Elab.Time": { + "relative_path": "lib/lean/Lean/Elab/Time.olean", + "sha256": "6b9da11286e522cb54d1759a5e4f93f50dc49b537c785daca8362c216c0141ef" + }, + "Lean.Elab.Util": { + "relative_path": "lib/lean/Lean/Elab/Util.olean", + "sha256": "d17dd23eb1ff8167dfe81c18ca2d79eb2aa863ad660be8f91057f952ac60ec2e" + }, + "Lean.Environment": { + "relative_path": "lib/lean/Lean/Environment.olean", + "sha256": "f65e86963b340104aec0500759c0221ce805877552a74a222444517efea4f327" + }, + "Lean.Exception": { + "relative_path": "lib/lean/Lean/Exception.olean", + "sha256": "348180c98395bf5936594ac1a00295baf447f096c9d55de58f1ad28b80ff532e" + }, + "Lean.Expr": { + "relative_path": "lib/lean/Lean/Expr.olean", + "sha256": "b109611aabeef2b002d78f15e7d05934c7af1dc5739a2aadde294f1417e828ee" + }, + "Lean.HeadIndex": { + "relative_path": "lib/lean/Lean/HeadIndex.olean", + "sha256": "a184c76eed310d6d6e6a855f50d25e694c10a0f3be2c8c2e01aafa23113aa817" + }, + "Lean.Hygiene": { + "relative_path": "lib/lean/Lean/Hygiene.olean", + "sha256": "f8122bf1f713f1514bdbdeb3cee8090c7d524255998bdb3f077a26fbf9e33bb9" + }, + "Lean.ImportingFlag": { + "relative_path": "lib/lean/Lean/ImportingFlag.olean", + "sha256": "ce6df3c54e60e9f9741b44b6c787667ff8edea324d61df14d97c3c6be2d4a314" + }, + "Lean.InternalExceptionId": { + "relative_path": "lib/lean/Lean/InternalExceptionId.olean", + "sha256": "314fb4e2c9c8a74700fb4ba28ff8996102d6960b101dc5e8ea058928b76671e7" + }, + "Lean.KeyedDeclsAttribute": { + "relative_path": "lib/lean/Lean/KeyedDeclsAttribute.olean", + "sha256": "6965a89059d292ffd11ede6d477a9895b5742df767da760a63958167e08709da" + }, + "Lean.LabelAttribute": { + "relative_path": "lib/lean/Lean/LabelAttribute.olean", + "sha256": "f6357ee28525c80e0e1e50f30d6abc8e9c212faf66266638907f7734baf8c4a9" + }, + "Lean.Language.Basic": { + "relative_path": "lib/lean/Lean/Language/Basic.olean", + "sha256": "116198598d0a090a3f8c1ac2df76863e2c130506768f741dd96c657b4f28f62c" + }, + "Lean.Language.Lean": { + "relative_path": "lib/lean/Lean/Language/Lean.olean", + "sha256": "ec21c3356101da99d833c4dbe27da14a587b238e0dcfead17dd1954358b4e730" + }, + "Lean.Language.Lean.Types": { + "relative_path": "lib/lean/Lean/Language/Lean/Types.olean", + "sha256": "e41961572ed5c15c53ca9829747714c5157397631bd11805558205cc21d2c300" + }, + "Lean.Language.Util": { + "relative_path": "lib/lean/Lean/Language/Util.olean", + "sha256": "7a02b960729bb110fe366fa1cfc75e7974ed6c4e984488b3d41c3701bae6d021" + }, + "Lean.Level": { + "relative_path": "lib/lean/Lean/Level.olean", + "sha256": "b0a2bdff71bacb1202f1c2b034fbfcaef3a928cb8508fe31751111872644168f" + }, + "Lean.Linter": { + "relative_path": "lib/lean/Lean/Linter.olean", + "sha256": "0ad71e4ddd414f842de88817808764b12d0dbc35fb0250beb219a6aac4d105e1" + }, + "Lean.Linter.Basic": { + "relative_path": "lib/lean/Lean/Linter/Basic.olean", + "sha256": "f15c89429080e69fa9ce443c7ab1462990d6cfb127c38ce3cc2e9c3150eaf319" + }, + "Lean.Linter.Builtin": { + "relative_path": "lib/lean/Lean/Linter/Builtin.olean", + "sha256": "65bcaf73e26b3b782cc55118edee888ef878f6eb321ef6c89ba6344c8c828727" + }, + "Lean.Linter.ConstructorAsVariable": { + "relative_path": "lib/lean/Lean/Linter/ConstructorAsVariable.olean", + "sha256": "d23b80487fc0b4ffb80cfe74517b2b44c317f857288c45e9573fa5595e7c0b76" + }, + "Lean.Linter.Deprecated": { + "relative_path": "lib/lean/Lean/Linter/Deprecated.olean", + "sha256": "ee83025c6435587e7822db2d39a94f7192a3be4828e76712936a6d687c1654b5" + }, + "Lean.Linter.List": { + "relative_path": "lib/lean/Lean/Linter/List.olean", + "sha256": "72b11db674930f01297e66d6fe9168b2711db7ed0f3a8062014bbe5628431447" + }, + "Lean.Linter.MissingDocs": { + "relative_path": "lib/lean/Lean/Linter/MissingDocs.olean", + "sha256": "89abae84ca6318a0f514ad6ab9164a28db6a35afe87b77303fca87d4a725dcff" + }, + "Lean.Linter.Omit": { + "relative_path": "lib/lean/Lean/Linter/Omit.olean", + "sha256": "8e0d622b1be4f992d2355f4ec978f33899e36c6caaeca50b3394326f74cab35e" + }, + "Lean.Linter.UnusedVariables": { + "relative_path": "lib/lean/Lean/Linter/UnusedVariables.olean", + "sha256": "d5bae599fc34fe808ea8d61cefa05405ae98d97184c208c92cbe883e9dfc20ea" + }, + "Lean.Linter.Util": { + "relative_path": "lib/lean/Lean/Linter/Util.olean", + "sha256": "e983ec22a68494993b52d4bc349e4fd8ed0e73c11a7236cdcfd14c58058da4a3" + }, + "Lean.LoadDynlib": { + "relative_path": "lib/lean/Lean/LoadDynlib.olean", + "sha256": "7bbb1aa363e257a2de2975ac17e31bbf58d4d4cd328d592710e6a718e71496b4" + }, + "Lean.LocalContext": { + "relative_path": "lib/lean/Lean/LocalContext.olean", + "sha256": "1b6191a3341ed46fa6b8dbcd3f24e245ae1b8c6ab39d080f2ff5cecc2e26250e" + }, + "Lean.Log": { + "relative_path": "lib/lean/Lean/Log.olean", + "sha256": "032fbe05a131072d1b0779947f012b10687e42ee07019d7ea29fff2d100e709f" + }, + "Lean.Message": { + "relative_path": "lib/lean/Lean/Message.olean", + "sha256": "c36f1a3906e9d18d564572f38bd3b687db02b21897db07f6470025ae522ea73f" + }, + "Lean.Meta": { + "relative_path": "lib/lean/Lean/Meta.olean", + "sha256": "206cf2fcc5bef1191f930198dfb2b0cd2042bf96f47c40faaf98cc105e137809" + }, + "Lean.Meta.ACLt": { + "relative_path": "lib/lean/Lean/Meta/ACLt.olean", + "sha256": "da1c2e3e8f486413a1fee34f34a938179cfdd72342ced421b82d230af508788d" + }, + "Lean.Meta.AbstractMVars": { + "relative_path": "lib/lean/Lean/Meta/AbstractMVars.olean", + "sha256": "a3e0a762ba6c0f8852c50c993c98208b5ce37e53cd374530f2b6f2cd119a4b34" + }, + "Lean.Meta.AbstractNestedProofs": { + "relative_path": "lib/lean/Lean/Meta/AbstractNestedProofs.olean", + "sha256": "fc0a2ed4ddd5bfc2c16958b017a88d2751126cec190d0eeb80a777c6825d2fa4" + }, + "Lean.Meta.AppBuilder": { + "relative_path": "lib/lean/Lean/Meta/AppBuilder.olean", + "sha256": "7cd2bf696029e7211829c3c8152df760b2e4695304ca409a76775c196ae56549" + }, + "Lean.Meta.ArgsPacker": { + "relative_path": "lib/lean/Lean/Meta/ArgsPacker.olean", + "sha256": "a7f9e66a5cc17f1ce38ec0b459f0ca4ab7b8a4273762e2c05b35ad57626b539e" + }, + "Lean.Meta.ArgsPacker.Basic": { + "relative_path": "lib/lean/Lean/Meta/ArgsPacker/Basic.olean", + "sha256": "6d74b8180f4fbc25df85bd09ae4ff159591fd5b7ec68dc02b798cb70a79112e4" + }, + "Lean.Meta.Basic": { + "relative_path": "lib/lean/Lean/Meta/Basic.olean", + "sha256": "f12db9629e0a571e3774816fec958dbc481f79f7b8a2c4c4bbd5208e12ccc24d" + }, + "Lean.Meta.BinderNameHint": { + "relative_path": "lib/lean/Lean/Meta/BinderNameHint.olean", + "sha256": "0d948af6513e8326ed601ea521ff00b87dd6d019bd5b60bf40860a7e5f5905f8" + }, + "Lean.Meta.Canonicalizer": { + "relative_path": "lib/lean/Lean/Meta/Canonicalizer.olean", + "sha256": "9262985c3ac4e2f8b7207fdeb2bf7fbab1db0dc6581b85a26c2cc27965ec43ee" + }, + "Lean.Meta.Check": { + "relative_path": "lib/lean/Lean/Meta/Check.olean", + "sha256": "502569420ced0ae9c7c72746fe0a34b7340279a7852e922a9b8ec5c183b97235" + }, + "Lean.Meta.CheckTactic": { + "relative_path": "lib/lean/Lean/Meta/CheckTactic.olean", + "sha256": "30e7beace22600567ab8f275bda3c48c83d8d80a14a654a0f723e125eef28377" + }, + "Lean.Meta.Closure": { + "relative_path": "lib/lean/Lean/Meta/Closure.olean", + "sha256": "092e59d5c44691e648c7e6b4151d18030b17a703b124d134c3e233d952c90058" + }, + "Lean.Meta.Coe": { + "relative_path": "lib/lean/Lean/Meta/Coe.olean", + "sha256": "72cd74ba7424353c0c7acb6cd05dd27d7f27d07fa8936fd54a96141d22d7671c" + }, + "Lean.Meta.CoeAttr": { + "relative_path": "lib/lean/Lean/Meta/CoeAttr.olean", + "sha256": "16993537a5507a03ac41462d5a54030993c6e9303353d59270b5df4762af31a9" + }, + "Lean.Meta.CollectFVars": { + "relative_path": "lib/lean/Lean/Meta/CollectFVars.olean", + "sha256": "d46e2325951ddff2997f5d37f9b688edc09d75d360711d9ae51415b9ed6a6dde" + }, + "Lean.Meta.CollectMVars": { + "relative_path": "lib/lean/Lean/Meta/CollectMVars.olean", + "sha256": "b2846166247972427c1225d20859aaa46fe676c321f3e4b8943ae064d9259b1e" + }, + "Lean.Meta.CompletionName": { + "relative_path": "lib/lean/Lean/Meta/CompletionName.olean", + "sha256": "2af094a0fd892457002a8b311a318ebb1d3b347f694fa5bd3c4a710bb3d0f5ae" + }, + "Lean.Meta.CongrTheorems": { + "relative_path": "lib/lean/Lean/Meta/CongrTheorems.olean", + "sha256": "ae1d73989795378f2db8d6725484544fbf700d26861669e26ed071fb3d5aa774" + }, + "Lean.Meta.Constructions": { + "relative_path": "lib/lean/Lean/Meta/Constructions.olean", + "sha256": "bd42abcf4b09dd47d7b07f34bce755794a76f242171f34720060f743c91d7e7b" + }, + "Lean.Meta.Constructions.BRecOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/BRecOn.olean", + "sha256": "91bb12647e28558fa3562e3ef84df4f40044d7a68fa2d0a0092f9a8b52852111" + }, + "Lean.Meta.Constructions.CasesOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/CasesOn.olean", + "sha256": "827e45d478f86cf087cc904ee3c3021343ac62fcf500ced79f733a631a72c4c8" + }, + "Lean.Meta.Constructions.NoConfusion": { + "relative_path": "lib/lean/Lean/Meta/Constructions/NoConfusion.olean", + "sha256": "4428b1ecf05f66c20cbfd068963aa5778bb1dc417f84e24a99010e93618d9268" + }, + "Lean.Meta.Constructions.RecOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/RecOn.olean", + "sha256": "08d7bf9cce44bfb9da0382e248b7232936f8e9b4e04d9f01272257e2c3e93e58" + }, + "Lean.Meta.CtorRecognizer": { + "relative_path": "lib/lean/Lean/Meta/CtorRecognizer.olean", + "sha256": "dc104bc4378dcd0427c4d67654ad199261907c9434bd5e59548f1960b7918c57" + }, + "Lean.Meta.DecLevel": { + "relative_path": "lib/lean/Lean/Meta/DecLevel.olean", + "sha256": "a2eed500e45408ea6f1531256849e4e47d7cb3ccdb8621c3a44769f45d23d37a" + }, + "Lean.Meta.Diagnostics": { + "relative_path": "lib/lean/Lean/Meta/Diagnostics.olean", + "sha256": "e64e866f33cb55305ffb4588647652a034aa08108bda8e49ba7b87f5b5c09dc8" + }, + "Lean.Meta.DiscrTree": { + "relative_path": "lib/lean/Lean/Meta/DiscrTree.olean", + "sha256": "a285696f66951a789b2d325baec39c256f247a40c4c442dcc5b5c631185a590e" + }, + "Lean.Meta.DiscrTreeTypes": { + "relative_path": "lib/lean/Lean/Meta/DiscrTreeTypes.olean", + "sha256": "35157be01b47d45c6ccfb978fe042752d42b919a13c2c59df749d78df28513d1" + }, + "Lean.Meta.Eqns": { + "relative_path": "lib/lean/Lean/Meta/Eqns.olean", + "sha256": "61d27ab1c2d1ea8db95324a4612e717c5e0a8c9fd7e6bb7cb13c928f4cc63703" + }, + "Lean.Meta.Eval": { + "relative_path": "lib/lean/Lean/Meta/Eval.olean", + "sha256": "8451e897121ce84e0e443be0ad1de1177143a1960c634d31c1b373d0ec30e5a1" + }, + "Lean.Meta.ExprDefEq": { + "relative_path": "lib/lean/Lean/Meta/ExprDefEq.olean", + "sha256": "ac84eb17f56223f5cf46553327dbfa0279b437802957cb292551c592b449a502" + }, + "Lean.Meta.ExprLens": { + "relative_path": "lib/lean/Lean/Meta/ExprLens.olean", + "sha256": "b8ac1969551532255d7a2b0223a00c65bf0bc468f90e7aba64fd6c697db6bb5b" + }, + "Lean.Meta.ExprTraverse": { + "relative_path": "lib/lean/Lean/Meta/ExprTraverse.olean", + "sha256": "b0cf3399e8837d8019f29b7e42b94028b42c6fcf40bca98a498ee9a3641ff948" + }, + "Lean.Meta.ForEachExpr": { + "relative_path": "lib/lean/Lean/Meta/ForEachExpr.olean", + "sha256": "6f2ade443619ee7d60f73bc62b4e1efd7372418d4f5b28b8b8233ac2c28ce1a9" + }, + "Lean.Meta.FunInfo": { + "relative_path": "lib/lean/Lean/Meta/FunInfo.olean", + "sha256": "b855ba9c1d30fec86c39339dd3cbfef0cfcdcdb7e78c25ad04103b37abc1a9ca" + }, + "Lean.Meta.GeneralizeTelescope": { + "relative_path": "lib/lean/Lean/Meta/GeneralizeTelescope.olean", + "sha256": "5ee0c1c92441c434c043593778ed21e47badeadce84e78a99682cedfad480372" + }, + "Lean.Meta.GeneralizeVars": { + "relative_path": "lib/lean/Lean/Meta/GeneralizeVars.olean", + "sha256": "796bc3bc0a297f547b39413e39611eb8829e642e7f44da2f4cea6d0d4ef56265" + }, + "Lean.Meta.GetUnfoldableConst": { + "relative_path": "lib/lean/Lean/Meta/GetUnfoldableConst.olean", + "sha256": "2ea066ddcc64d26c2d70e77bd3c7b015c8ee3f755d10187352eb155962d91427" + }, + "Lean.Meta.GlobalInstances": { + "relative_path": "lib/lean/Lean/Meta/GlobalInstances.olean", + "sha256": "8265fb3b50c621767dc77e38921e2fe7360694ce5b7ac3e24bdc67e0c3946f57" + }, + "Lean.Meta.IndPredBelow": { + "relative_path": "lib/lean/Lean/Meta/IndPredBelow.olean", + "sha256": "c93d1f840670b555e569ac9d262d1f41decd51f3d134d54ff4e53bb542e9cb58" + }, + "Lean.Meta.Inductive": { + "relative_path": "lib/lean/Lean/Meta/Inductive.olean", + "sha256": "cbd800e5e3644765969dc14c322b700120c9dd2c3db0d499e72c13f607fb29aa" + }, + "Lean.Meta.InferType": { + "relative_path": "lib/lean/Lean/Meta/InferType.olean", + "sha256": "a9e3c61dd6022e6864ca3416c5567360975a3781076d8dedd4b93507bfe12703" + }, + "Lean.Meta.Injective": { + "relative_path": "lib/lean/Lean/Meta/Injective.olean", + "sha256": "022f6530d2761e0fd32e4a8a1d390badfe3bbf852a92bebf2269b4cacf93ac9d" + }, + "Lean.Meta.Instances": { + "relative_path": "lib/lean/Lean/Meta/Instances.olean", + "sha256": "fcc360ddf8ee95db9d62118b0c262c6695b38251dcd96f086fee6c5195966516" + }, + "Lean.Meta.IntInstTesters": { + "relative_path": "lib/lean/Lean/Meta/IntInstTesters.olean", + "sha256": "33498b0c4626bd28ce45b7a3f7996aaee28f3cea1e8a9a6cbbe6fdeb24619209" + }, + "Lean.Meta.Iterator": { + "relative_path": "lib/lean/Lean/Meta/Iterator.olean", + "sha256": "101d4d68efea3a23fbd0dc5f16e63ff16c65b391862a09feee2f7930dc671703" + }, + "Lean.Meta.KAbstract": { + "relative_path": "lib/lean/Lean/Meta/KAbstract.olean", + "sha256": "1ff48dc21dc7daa5701ec93ebf8dea8e853eb9c76c7f08df3c047b2e364c0fd6" + }, + "Lean.Meta.KExprMap": { + "relative_path": "lib/lean/Lean/Meta/KExprMap.olean", + "sha256": "a61c80321e32eb1ac29c70f05a557bc9a950b6a65d0503e94031cd21c697f84c" + }, + "Lean.Meta.LazyDiscrTree": { + "relative_path": "lib/lean/Lean/Meta/LazyDiscrTree.olean", + "sha256": "0e52ab3e1bba285513237aa0ad00ebbeca9f6f2de5e6ffed01aa0aff4ebce915" + }, + "Lean.Meta.LevelDefEq": { + "relative_path": "lib/lean/Lean/Meta/LevelDefEq.olean", + "sha256": "039d6b9b7f252227092b329102542df7d9c09edceb1aefa45fc712078c65c5d7" + }, + "Lean.Meta.LitValues": { + "relative_path": "lib/lean/Lean/Meta/LitValues.olean", + "sha256": "fc41c863bde3e203433870eb601640349cb7855f816bdebbde1a2a204c9bdace" + }, + "Lean.Meta.Match": { + "relative_path": "lib/lean/Lean/Meta/Match.olean", + "sha256": "548ceb8925264b3c53204550bfea3548b9e73b11f0124d9a7f4343aed053ad9d" + }, + "Lean.Meta.Match.Basic": { + "relative_path": "lib/lean/Lean/Meta/Match/Basic.olean", + "sha256": "ad8f2a68e4366a7c0c5939323446515ac428595f1da113a506bf12039fb16442" + }, + "Lean.Meta.Match.CaseArraySizes": { + "relative_path": "lib/lean/Lean/Meta/Match/CaseArraySizes.olean", + "sha256": "e221018a693db011a0414635b7b68c8b8388950b2c2d4731ce41a6a5576a1d57" + }, + "Lean.Meta.Match.CaseValues": { + "relative_path": "lib/lean/Lean/Meta/Match/CaseValues.olean", + "sha256": "537ddad23a87967f7088967a2a347eb108cc36e2d4e4d9ffb0a8396d65da88df" + }, + "Lean.Meta.Match.Match": { + "relative_path": "lib/lean/Lean/Meta/Match/Match.olean", + "sha256": "2e73790b9ba9e908afaec1f9636dbe6f8ca5388dd11caa89f03e0e9579138516" + }, + "Lean.Meta.Match.MatchEqs": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchEqs.olean", + "sha256": "3e0c930d82985234eaf74ec74fb3bc7dffc959608f43bd38ac33a884500315a7" + }, + "Lean.Meta.Match.MatchEqsExt": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchEqsExt.olean", + "sha256": "bfe53903e9962eeede9b619f0ba796108662c4945af59198a5834799589b1d68" + }, + "Lean.Meta.Match.MatchPatternAttr": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchPatternAttr.olean", + "sha256": "6c7c6f96c64e483fc2864cb94a9e2f1fe2570e04660100eec221bb0511e5684a" + }, + "Lean.Meta.Match.MatcherApp": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp.olean", + "sha256": "e2ed9a86cbc2817d5fa9a023ef571b6b077e2626b8c4e6799fc4f9c31bfa9520" + }, + "Lean.Meta.Match.MatcherApp.Basic": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp/Basic.olean", + "sha256": "cd872e793052ffcbbdaed58e949e35afe056e7b7177b49c70d3c5fd6cb269825" + }, + "Lean.Meta.Match.MatcherApp.Transform": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp/Transform.olean", + "sha256": "df0e6ddff62c7c9906a8704ed1338b841299acbdb0c4894eea4dd9f253824cb4" + }, + "Lean.Meta.Match.MatcherInfo": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherInfo.olean", + "sha256": "83151f202d8e0d8b58fd86326458d33e3f8f060038aaccc7909d07cfb8c4a5c6" + }, + "Lean.Meta.Match.Value": { + "relative_path": "lib/lean/Lean/Meta/Match/Value.olean", + "sha256": "0c40eecc0e0da4ec9cc2eec21580f3493911fb56c753dab89c51327bfb64551a" + }, + "Lean.Meta.MatchUtil": { + "relative_path": "lib/lean/Lean/Meta/MatchUtil.olean", + "sha256": "5ff0623e662f1b1ba9035709de58345cf18417f05bf3580448d963471d4f1f93" + }, + "Lean.Meta.NatInstTesters": { + "relative_path": "lib/lean/Lean/Meta/NatInstTesters.olean", + "sha256": "3a54ef6c555c2304cd894a59b7519e7cf1138c5082ea7c6b541d2558f68d729e" + }, + "Lean.Meta.Offset": { + "relative_path": "lib/lean/Lean/Meta/Offset.olean", + "sha256": "e9bccfe44f2cb64ac53bdb8d4391720754a15706c982a7f4ee8b3c19b2001ed2" + }, + "Lean.Meta.PPGoal": { + "relative_path": "lib/lean/Lean/Meta/PPGoal.olean", + "sha256": "1ff4e4b1dd870a3fc09b5b9bd5bdf20dd4a0263d2a652b4d4d3461495e7d713b" + }, + "Lean.Meta.PProdN": { + "relative_path": "lib/lean/Lean/Meta/PProdN.olean", + "sha256": "d8b86b781fa66571ceb5087c16cac87cd37beb344e9134818bff6e4003f2a6b4" + }, + "Lean.Meta.RecursorInfo": { + "relative_path": "lib/lean/Lean/Meta/RecursorInfo.olean", + "sha256": "c7deca642d62ab08712aa143b716f781872a5e421470246d94bc9fb7dd862b47" + }, + "Lean.Meta.Reduce": { + "relative_path": "lib/lean/Lean/Meta/Reduce.olean", + "sha256": "6ae0326d4d14d180af14176daf097cf236bd4347a95d87b93a7e5996d1ae95ea" + }, + "Lean.Meta.ReduceEval": { + "relative_path": "lib/lean/Lean/Meta/ReduceEval.olean", + "sha256": "50aaeb5ac37fb6154b0e2c1c5d3085f3cf61736ec3b316ab2bd9e7d4d7babc40" + }, + "Lean.Meta.SizeOf": { + "relative_path": "lib/lean/Lean/Meta/SizeOf.olean", + "sha256": "af408b51fc723ab8bd677b7e5a84d33b6639d1e481b7f058d3e5f16200c7a5c5" + }, + "Lean.Meta.Sorry": { + "relative_path": "lib/lean/Lean/Meta/Sorry.olean", + "sha256": "56b4c84f52c8c7925b6c1a850fb91ff7d7966e113ed79a39e140ae46f5fde7a9" + }, + "Lean.Meta.Structure": { + "relative_path": "lib/lean/Lean/Meta/Structure.olean", + "sha256": "e5f9fa309279c95a5cf27878c316b302eba85e26b4aa1d6e85f5b43d6453616a" + }, + "Lean.Meta.SynthInstance": { + "relative_path": "lib/lean/Lean/Meta/SynthInstance.olean", + "sha256": "dc0a3b8ea0ef34849ba5ca57477fd5ccb37d7ccad92151d8b231f17afb86c5dd" + }, + "Lean.Meta.Tactic": { + "relative_path": "lib/lean/Lean/Meta/Tactic.olean", + "sha256": "ad4914ed10cf80c2d4a2388d6fb8af91cc2d2991c9475e8cab2eb6ba7d57ea22" + }, + "Lean.Meta.Tactic.AC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AC.olean", + "sha256": "ee57ccf20ad198b447ea1b6e0f7ceb4a6b3ae399b5dc45ca144164e7f41148fc" + }, + "Lean.Meta.Tactic.AC.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AC/Main.olean", + "sha256": "2bdbf30c5961d39ed784e11ba8bbbee10f34d882c8e515bfedfaae65c2983174" + }, + "Lean.Meta.Tactic.Acyclic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Acyclic.olean", + "sha256": "1d138ed59a13cdb5360dee24852ee3dcef4d97a3da34e175c3d5ba1a5afbfe98" + }, + "Lean.Meta.Tactic.Apply": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Apply.olean", + "sha256": "c1283b20feace19b65fc7e23af16221b8d0a14ac59dd7c70d8d0a83222e94baa" + }, + "Lean.Meta.Tactic.Assert": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Assert.olean", + "sha256": "7673647ca3e547e0078675263dc676f122d87c602266d432c78229cb716be2fe" + }, + "Lean.Meta.Tactic.Assumption": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Assumption.olean", + "sha256": "bbe1c2ac91bb85c39556a28690834034b3faff15ffa79f396f5646154597185b" + }, + "Lean.Meta.Tactic.AuxLemma": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AuxLemma.olean", + "sha256": "b621afecfc83539db089cf44ceee268d994ee0371559db2bafee8341ade61caa" + }, + "Lean.Meta.Tactic.Backtrack": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Backtrack.olean", + "sha256": "6ba89a26edd430b58166fa46607e7b7e7904172b1984de835b7eb9a584fec426" + }, + "Lean.Meta.Tactic.Cases": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Cases.olean", + "sha256": "f82be51283b6ca0a88b466e325061872da1ca78317d784222c2d4d5f095f25d9" + }, + "Lean.Meta.Tactic.Cleanup": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Cleanup.olean", + "sha256": "5daf92f058790a58da353d444701d231bc0d7ffac8ac7a641a396f71c09150d2" + }, + "Lean.Meta.Tactic.Clear": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Clear.olean", + "sha256": "829fa3bd204a603f0686f6060b474f98815ba786324b91fbf166c40783702c4b" + }, + "Lean.Meta.Tactic.Congr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Congr.olean", + "sha256": "2fe9a126baf313a410bca67c2ba600b5397776b3096845ca5bfd4c71f4065195" + }, + "Lean.Meta.Tactic.Constructor": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Constructor.olean", + "sha256": "867577fa39e8b883035764c3dc65017fdb335a365931aab74461676eb3d4ff43" + }, + "Lean.Meta.Tactic.Contradiction": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Contradiction.olean", + "sha256": "4f2fea4e956ca33f43b6958efcba64ec2f7da8199bf2e8305ea09dc0a9a387be" + }, + "Lean.Meta.Tactic.Delta": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Delta.olean", + "sha256": "b80e1e36a4f334d593cc5c2692020ccf113e0066cb9bccf59b88d706a1ed3303" + }, + "Lean.Meta.Tactic.ElimInfo": { + "relative_path": "lib/lean/Lean/Meta/Tactic/ElimInfo.olean", + "sha256": "59a71e16fbbfb5a22573b245e4d7068eee6d9b0d40b49602cdd03e0d4e9bdc5a" + }, + "Lean.Meta.Tactic.ExposeNames": { + "relative_path": "lib/lean/Lean/Meta/Tactic/ExposeNames.olean", + "sha256": "3b31fb2dba571938bce63170aadf82501c229ac457caad8427c58eef935ba444" + }, + "Lean.Meta.Tactic.Ext": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Ext.olean", + "sha256": "22bb0d168e310524c9788a3c415614b51ed048dbfd5a51652f46b0068c77b4a2" + }, + "Lean.Meta.Tactic.FVarSubst": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FVarSubst.olean", + "sha256": "8c21b3a5802e4d08978539b78c1dbb67508903b3f21978b38ef9cc57c270a27c" + }, + "Lean.Meta.Tactic.FunInd": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunInd.olean", + "sha256": "6296c74e67fb553b1bc764a5e07c2d5bbb6c4ebd3b323557c64d01267d1801ab" + }, + "Lean.Meta.Tactic.FunIndCollect": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunIndCollect.olean", + "sha256": "abb578a79335d722c9d69eef073a1ccb64c966b6b7dcdf501b9825181ea2165d" + }, + "Lean.Meta.Tactic.FunIndInfo": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunIndInfo.olean", + "sha256": "7fcea4ed90a733cf9b1d874e6c805f123f293da6379e4a658df2333f64cd5bc5" + }, + "Lean.Meta.Tactic.Generalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Generalize.olean", + "sha256": "c6b2a2530dbb3966ededa8eec4476801bc7c85e1a69c17519d2b47a6e3bb3047" + }, + "Lean.Meta.Tactic.Grind": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind.olean", + "sha256": "a4a04684e58d43aa05cb1c41eb3e18cf6af8da64c935a88fea4b41e394461a78" + }, + "Lean.Meta.Tactic.Grind.Arith": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith.olean", + "sha256": "3cb51d31133b73246d8131265dafb9cede95fc310dbe7bb4b5b7ece65b2598ad" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.olean", + "sha256": "dd481e2963c500cd4c4f686f800ae5d5ab818b1055fcd1cb95bab98516dbf96e" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.olean", + "sha256": "78cc1a489ac6c1dd48dbeae02db742ed4a0867263e877192ab4b417807b73251" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.olean", + "sha256": "bd0a7b837aeda3d44ba972c14219b3f8bf1fda4e68fa1b7b2a98b911007d6ae0" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.olean", + "sha256": "1e84cc67e9674371b9e1ee937f052ebaf33f949ee98fed97ae3e5a0af14ad8bc" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.olean", + "sha256": "bbaf4808f9bef4fd58cffdd9dbbebcaae4a275b740f912f4357bfcd71807dad1" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.olean", + "sha256": "bb82e33912900ffca9cb8b05ba27175bc5be751f59921b09f13322dff9997fdb" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.olean", + "sha256": "868752823c6951c957840f933609d6fe1dc86026fd810479862fdc3c73b84399" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.olean", + "sha256": "8092837e82e32858cfe423c1f20453c3c38a013c54abb05f872b1233cfbe8e5f" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.olean", + "sha256": "370a4249179e8a0d228121d74a22194b50afc23395fcc3d8024621527d703ac1" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.olean", + "sha256": "3c8f3c889d553bf6ef43ed0c444859e905cd162356ce04f85247b0456a4f7b4e" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Search": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.olean", + "sha256": "61aca638560fc03fc81066bda85ae7ed4cd041d810cd6ccfc22126d34acddbd5" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.olean", + "sha256": "50bd8fa6211db0a214bd45a0f0e39b717459c16a30ecb25f9cb952d8375bccef" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.olean", + "sha256": "049f36bd49ee5222ca1f80966c97b13f53c4c7d9671d9cf496d582bf1c502671" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.olean", + "sha256": "d9541c657bbd8498736f341ac0e4389234e57be3d769b33a637f951da6e098f7" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.olean", + "sha256": "2da35cd1a1295137544c382e41dbe533cd98dc6fc18c92de7a0c8986518f48ac" + }, + "Lean.Meta.Tactic.Grind.Arith.Internalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.olean", + "sha256": "1f8dbae8cba46c6011d127e73c6d23e1594b3c13079a8167c9ff0b5d55ceaeb9" + }, + "Lean.Meta.Tactic.Grind.Arith.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Inv.olean", + "sha256": "0750fb3fce8b1e8ec98480b4b6ab8360e5f205371b1d575f53357702ae2bb702" + }, + "Lean.Meta.Tactic.Grind.Arith.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Main.olean", + "sha256": "8eb37977bf901bab0ad9873bfbde7c593fbaf6ff8d0c1c6de61597ec91de58c0" + }, + "Lean.Meta.Tactic.Grind.Arith.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Model.olean", + "sha256": "52f869b8a4523f3f8327495940a786c4670cf48b997d432c20640384e7301003" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset.olean", + "sha256": "bd8b615afcb4c53f5e711d9ab7f88881785088cd9b9f81c6b80b64432a916166" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.olean", + "sha256": "817db989d2e71b096c86076070f270ce02efefcf2c4b0cc8eb35a85ffe592097" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.olean", + "sha256": "3ffe0874b9209d41c8a12f845f4a23c37ed67985952ec8cf4fba6607b0d49bb2" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.olean", + "sha256": "13e17f706763e0e5001c386f41180d240fcc3cb3bb0e5b0704b1c6e89f8690dc" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.olean", + "sha256": "2af0eddf89eb682293b49189b0ecfdb86e7b2cb70ca6983d35edba6fc47b6825" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.olean", + "sha256": "cc0adfcd94231e97e1d8a5d9fd855b4ba06f77d4974d9f60bf8fcb1fad3429cb" + }, + "Lean.Meta.Tactic.Grind.Arith.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Types.olean", + "sha256": "6438183d9d97bcba306b3c98d0c4df35f16ae24156cbd92211a215ee8e0e9508" + }, + "Lean.Meta.Tactic.Grind.Arith.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Util.olean", + "sha256": "059afefed5207fd3bb58ff11aa196e5cb4fdd3d0c2f03f70ab3a302f3fb59612" + }, + "Lean.Meta.Tactic.Grind.Attr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Attr.olean", + "sha256": "e0809449692b76c1e0ae127a742c8c83858306fe2612eb59a238e5600e6437b0" + }, + "Lean.Meta.Tactic.Grind.Beta": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Beta.olean", + "sha256": "34027591ddea6317ba5bc6f29ec01c6a1cd2dc75c8b2af5b5d5e6fede7c2813f" + }, + "Lean.Meta.Tactic.Grind.Canon": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Canon.olean", + "sha256": "7e0dcfb39fd87bd7aa566da21f8cf3e0055adf5abdfab8c4dcd92ff022cffc99" + }, + "Lean.Meta.Tactic.Grind.Cases": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Cases.olean", + "sha256": "a79fdef9eaf0a5a89b2369d0374b43efa50ef7eb137bb143aea1b6968130fcd5" + }, + "Lean.Meta.Tactic.Grind.CasesMatch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/CasesMatch.olean", + "sha256": "cae5f088bd9191b15683eb230c385d3cf95b9cc36c5aa8fd237ef6abd6240e79" + }, + "Lean.Meta.Tactic.Grind.Combinators": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Combinators.olean", + "sha256": "573a8a2af44136b8fde8d93f561948f97b61ed2b0445b4af06a07e82901b004c" + }, + "Lean.Meta.Tactic.Grind.Core": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Core.olean", + "sha256": "603facdbeba83aeb053dc352948b86af9017b6a6e7b546a1a1516f03fea9c273" + }, + "Lean.Meta.Tactic.Grind.Ctor": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Ctor.olean", + "sha256": "2e49aeb70d54c80eecfae5c718a65d31917c4d875090b306049d463db43c230b" + }, + "Lean.Meta.Tactic.Grind.Diseq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Diseq.olean", + "sha256": "712b2965e98032727d42acecf75d2845c6d20828c9aa6f4cb7346b51100c6761" + }, + "Lean.Meta.Tactic.Grind.EMatch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatch.olean", + "sha256": "b3075bba2fa4af4839446ccc345b04063a1eeaf1f396aa027550e0d67eaf46d6" + }, + "Lean.Meta.Tactic.Grind.EMatchTheorem": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.olean", + "sha256": "7e393dd56ee80f27d92e457f4c2070d2fe2831142981438b7dff6b652ed6b12e" + }, + "Lean.Meta.Tactic.Grind.ENodeKey": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ENodeKey.olean", + "sha256": "ca0345179b9421b8efb30bed06820116843d9701e9c9f84e0824a0961b5251a5" + }, + "Lean.Meta.Tactic.Grind.EqResolution": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EqResolution.olean", + "sha256": "ed9d38ede8c44a14131ac484fcaac127fd889468856ea78f158cb8f7c7c5f9e1" + }, + "Lean.Meta.Tactic.Grind.Ext": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Ext.olean", + "sha256": "a7c1cee7f1e76d45b3787d0a7c2036967fffd7c6d780dad968bc5e08e0c674c7" + }, + "Lean.Meta.Tactic.Grind.ForallProp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ForallProp.olean", + "sha256": "923892a0ed79c2156b6df9cc23f561b77dc2c935ccb9b1d95122bab0e20fef97" + }, + "Lean.Meta.Tactic.Grind.Injection": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Injection.olean", + "sha256": "7c448e2fc0d16e61b6ad822651c7b35b8213dd18fbd4927017595d9fcd96af63" + }, + "Lean.Meta.Tactic.Grind.Internalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Internalize.olean", + "sha256": "7cd74b074c2e9deae6791b7045b6dec8f9056d41b96c9072020b051d67402323" + }, + "Lean.Meta.Tactic.Grind.Intro": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Intro.olean", + "sha256": "45d35493ac631af84097a78ea4b02bc5cc814c0ac8b598b36049279ac7ed87f3" + }, + "Lean.Meta.Tactic.Grind.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Inv.olean", + "sha256": "5111a484cd46c8d2263629540e4128cef9f30b74ccf62a6eded8ac56d8481fa3" + }, + "Lean.Meta.Tactic.Grind.MBTC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MBTC.olean", + "sha256": "596858a07ca041824937bfd08b38cdef09d32b08749962546f2b8abdb7e24192" + }, + "Lean.Meta.Tactic.Grind.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Main.olean", + "sha256": "e1e5ab7d0c967a50c2a38a5490a1a8c537e843da2c3f5a56e7cda971208bfd93" + }, + "Lean.Meta.Tactic.Grind.MarkNestedProofs": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MarkNestedProofs.olean", + "sha256": "3ab8dc54fab42c6683c63aae87ad0e606b3832d1f2391087ec7e698d5fa2fbcb" + }, + "Lean.Meta.Tactic.Grind.MatchCond": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchCond.olean", + "sha256": "ab35239747c6ca8c3833e709aaa2aa723d0525620ac2634241f72963ac9bed82" + }, + "Lean.Meta.Tactic.Grind.MatchDiscrOnly": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.olean", + "sha256": "0de0cdfbedfabfa048e98e885f3f1eea39e583aec8bcc2a50a5698f7a0df7884" + }, + "Lean.Meta.Tactic.Grind.PP": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/PP.olean", + "sha256": "23d560a5339928172099a9062d083f940a0a16e6c0b784dfe2a9f356e8682bb7" + }, + "Lean.Meta.Tactic.Grind.Parser": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Parser.olean", + "sha256": "052643551a1eb5fbfe4afdca2eb7ae6260628ef93f4813744cbda5a138eb751a" + }, + "Lean.Meta.Tactic.Grind.Proj": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Proj.olean", + "sha256": "1383ad6bc4a47cea522c9b9f542049aad4b818f4bf208ed98d1f56088d322a9a" + }, + "Lean.Meta.Tactic.Grind.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Proof.olean", + "sha256": "7e5f3d9016d71c938eb5bf7c6188d50dfe2b148189748b018e13d1d1f26758c0" + }, + "Lean.Meta.Tactic.Grind.Propagate": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Propagate.olean", + "sha256": "ba25b0259e25398cb28d7a6343b76a9ffae30a0e7759f2bbba03cf439d27ee49" + }, + "Lean.Meta.Tactic.Grind.PropagatorAttr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.olean", + "sha256": "c21c3865df64f8a2bdab20ab5a5658badebe0b370640e63e7ce8ae0620bc98b3" + }, + "Lean.Meta.Tactic.Grind.ProveEq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ProveEq.olean", + "sha256": "6fd15eeee6dce37a980a5036eb99716960dbbc6650d14b71cbd63a0f854578e7" + }, + "Lean.Meta.Tactic.Grind.RevertAll": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/RevertAll.olean", + "sha256": "63335a05f51b1b99b3bc891e774ed07ae7ccf470b36701c9a47472a2023b72dc" + }, + "Lean.Meta.Tactic.Grind.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Simp.olean", + "sha256": "eb9a419af181bdcc13018b73f8b5ef9b0cce6b3d8e69bb777a9464d54d7489d0" + }, + "Lean.Meta.Tactic.Grind.SimpUtil": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/SimpUtil.olean", + "sha256": "082ec13ed64da168e10a1d19d1f2080f417e069936488d9628652d2e83bf96ab" + }, + "Lean.Meta.Tactic.Grind.Solve": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Solve.olean", + "sha256": "838552f0e3f9901c03de3ee16533956fcc7677abcd393eaa85fc7e14c67c0c07" + }, + "Lean.Meta.Tactic.Grind.Split": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Split.olean", + "sha256": "9be21a776a8dbb641a0af947eebf4525341bfa829b3ae7e7ed5eb20855727d37" + }, + "Lean.Meta.Tactic.Grind.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Types.olean", + "sha256": "50bd2bb81627e5f915ee54c8730bb4d5403de12cca8a05a41f2f280b693772f9" + }, + "Lean.Meta.Tactic.Grind.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Util.olean", + "sha256": "02603b8094844f61ba32b6173beb06896e101dac5d581ca4ef9e82b17f4ba473" + }, + "Lean.Meta.Tactic.IndependentOf": { + "relative_path": "lib/lean/Lean/Meta/Tactic/IndependentOf.olean", + "sha256": "d6abc51e9488051912586a96926f55ddb9f0368c8891d5f89ff2d684122148fe" + }, + "Lean.Meta.Tactic.Induction": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Induction.olean", + "sha256": "a8fdc96571cc600fd47e2e68d84c51fe8afc537c08ab63d1e69ba5b4f518f4fa" + }, + "Lean.Meta.Tactic.Injection": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Injection.olean", + "sha256": "6d25fe6e9d8e4af470d9cd1074402577fd08575b0306faf9c78411c8a5e7578a" + }, + "Lean.Meta.Tactic.Intro": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Intro.olean", + "sha256": "a781ab0eafda9549477f2e90e0dc6ea708bbbda6d12f7390eaba879ecf6146a7" + }, + "Lean.Meta.Tactic.LibrarySearch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/LibrarySearch.olean", + "sha256": "c943f49809c5e0037e4239b05e441c2331cb48b24ca17f9146e5197458ed3ad6" + }, + "Lean.Meta.Tactic.NormCast": { + "relative_path": "lib/lean/Lean/Meta/Tactic/NormCast.olean", + "sha256": "8758122a8aa03b65194824837c9501ff7a57f6e56c3645ce16cd39935122465b" + }, + "Lean.Meta.Tactic.Refl": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Refl.olean", + "sha256": "39762b479efc2290610ab53ea0f9a7a67643f6684cb0fa5cdc1ff52cd5589d8a" + }, + "Lean.Meta.Tactic.Rename": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rename.olean", + "sha256": "633edd2088d9aab13bbb93c7da98451571c025dd4fa28c7adb7a1f14dede0a82" + }, + "Lean.Meta.Tactic.Repeat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Repeat.olean", + "sha256": "54854192d18a935b34a838ec68e7b5c86f7efc2831bbfe623057415260b84553" + }, + "Lean.Meta.Tactic.Replace": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Replace.olean", + "sha256": "a542783069ace49d9d9e92aa9f3cb725c98f94d5cdd4977a1154569dad20f1b5" + }, + "Lean.Meta.Tactic.Revert": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Revert.olean", + "sha256": "f6454fe8a940ada423be12c9a36033ecfbba13b71d0ed59fad2e9d522d46df10" + }, + "Lean.Meta.Tactic.Rewrite": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rewrite.olean", + "sha256": "3d61c66d1f775792f0c463b3ef6666a399fff92c2f7f1b29c605c99e02941897" + }, + "Lean.Meta.Tactic.Rewrites": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rewrites.olean", + "sha256": "5a2278edd2383bca036422ea43a484ccae7a0bb2bc7e7e15f0326a32e2330786" + }, + "Lean.Meta.Tactic.Rfl": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rfl.olean", + "sha256": "d2e5e722c4f2e3c9f291c02c05a671917d71aef645e34c0c01dbfd8a4ef23898" + }, + "Lean.Meta.Tactic.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp.olean", + "sha256": "a744b6973cd9b833699a6c19c0fa40e4dbfb6041fb08a6ca4de0823d3d56fae0" + }, + "Lean.Meta.Tactic.Simp.Arith": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith.olean", + "sha256": "b8b2030520be215f2121c9fab8608f7fd58ea80e48ffa5598fce3d1f948950c1" + }, + "Lean.Meta.Tactic.Simp.Arith.Int": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int.olean", + "sha256": "4f1c85c9e598fc31a7e1fc7e6f8d06d1c1eaa5146c624842e8ec87b58e5d9994" + }, + "Lean.Meta.Tactic.Simp.Arith.Int.Basic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.olean", + "sha256": "d03e49ecd4dfdec58f2ac9f261d983bea4023df4c78f7514bb7f6c40cdbb8bbf" + }, + "Lean.Meta.Tactic.Simp.Arith.Int.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.olean", + "sha256": "2766ba66e280f3beb4bae57de6de59a2f92647472cbe608bec350dbabdaaba11" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat.olean", + "sha256": "a035ca9e9317ad56e2e70046e0864586827218ad7e25cb7366fe532e010b1007" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat.Basic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.olean", + "sha256": "f80614c7ae4ff336b04162d11f2574e0848f38f72882fe919d759eaa09590f72" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.olean", + "sha256": "d77e898ebdaa21da0b6f6fa24eb4804a8b45ecf4ed7834aa26bfe8493b51148a" + }, + "Lean.Meta.Tactic.Simp.Arith.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Util.olean", + "sha256": "e43e2fa36cc77656ee34ca02b79897664215ce95e653cada87db0781111193ff" + }, + "Lean.Meta.Tactic.Simp.Attr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Attr.olean", + "sha256": "59dacc00728793da658e06c75bf20eb166ca57c100434714c7a7b7349149e99b" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.olean", + "sha256": "9e91488ad971f433fc8c18b870ddae5174f4fd8a80f9aee7e195223acf0813e7" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.olean", + "sha256": "aba24528cdf8549fefad4371d2ed8279dcc5bd4566d9ca59ccc721f760d51c56" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.olean", + "sha256": "18ba1c46202bae2dd5205e93db1df217fc9d213fbdc687452d9d76421437ef66" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.olean", + "sha256": "70bb04834a476008fe448165e8662a0437c82012e348ec19b6039773051fc91d" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.olean", + "sha256": "5b8217fa58f2deae0b8a99202da2367fedbf91cda77486d0ea9201b05a0720ae" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.olean", + "sha256": "fe618da592aafcfc1b597b118c88b962b603f55096926e7c77cd5f237a393c0e" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.olean", + "sha256": "9535c409ebeb0c3064e5b98fa9f953fbb93e15db3f2116dc46138ac0ff700c0a" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.List": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.olean", + "sha256": "93a9382bd2f855ac48c61e6886f02b85f81593552747a1dae72b3b10afc71a70" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.olean", + "sha256": "6b8d3d8807c31912616ae4818014da1e44cbfa398eeae525170b864185b3f324" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.olean", + "sha256": "a14d545e6a296624fbfc25dc02e8a49e0be6e3285f47960af9dbb766e872a024" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.String": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.olean", + "sha256": "bae98881832f2482d6e98c1b9eb11cc28e984ee2b7ac2d3e3d92ceade31bb7c6" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.olean", + "sha256": "9afaab454e44fd3c1a60907f38ee31b9057682bb6b66503e3136b23a0e51a0eb" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.olean", + "sha256": "97194969f1662051ced0134ccd1cbc4051c02ed0afd46ecff6daafb413645652" + }, + "Lean.Meta.Tactic.Simp.Diagnostics": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Diagnostics.olean", + "sha256": "8fb74efbbe0d898b4bee2b53a996bb925cd3dfdd4bf3098086d07fdad9c093f6" + }, + "Lean.Meta.Tactic.Simp.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Main.olean", + "sha256": "90f3c5c41d8d10a7b82110a9d188db8661f730c8430102696a6050a9e819944d" + }, + "Lean.Meta.Tactic.Simp.RegisterCommand": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/RegisterCommand.olean", + "sha256": "5e296fcd42394e5fa5a137358753eb347872076a0e8dc3ef5e31b483ac58af39" + }, + "Lean.Meta.Tactic.Simp.Rewrite": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Rewrite.olean", + "sha256": "e6377cde2f937751efc04e43b032505bfed7ec5c1f13678c3cb456268e90d2c2" + }, + "Lean.Meta.Tactic.Simp.SimpAll": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpAll.olean", + "sha256": "f2aedf17c8196a3fcc3ba0a79d2dee82b6599e2623e0e5336940943fe294316d" + }, + "Lean.Meta.Tactic.Simp.SimpCongrTheorems": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.olean", + "sha256": "2a29138060df8d5e09ad070b170d167fc490713073b36b38371e676c83578119" + }, + "Lean.Meta.Tactic.Simp.SimpTheorems": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpTheorems.olean", + "sha256": "b6f48b1bf34a7832d9a809b108a3aa8606c13afd2376b6c2c79f7045425e0e7d" + }, + "Lean.Meta.Tactic.Simp.Simproc": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Simproc.olean", + "sha256": "913ac372ccd4b4445b346d16d2ba702bf74d8ea65e62401b7b502b016bc82750" + }, + "Lean.Meta.Tactic.Simp.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Types.olean", + "sha256": "382bf34c3320d34ce0ba097804f91ee702480fb358709d1a376399ab20ae2767" + }, + "Lean.Meta.Tactic.SolveByElim": { + "relative_path": "lib/lean/Lean/Meta/Tactic/SolveByElim.olean", + "sha256": "65859e5f73882352b2e665afdd9ae7f9dbd122ef99cdaa6422fc4e37c030d459" + }, + "Lean.Meta.Tactic.Split": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Split.olean", + "sha256": "0e8d4c9c735a78acc8977e81bc84bd39d2390093d889445f006ba6d5f6ad5b3d" + }, + "Lean.Meta.Tactic.SplitIf": { + "relative_path": "lib/lean/Lean/Meta/Tactic/SplitIf.olean", + "sha256": "a39ffae4f96a41e30a2c3a88468103c3c716942214fc8805357490e903b2ef67" + }, + "Lean.Meta.Tactic.Subst": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Subst.olean", + "sha256": "44938a993d4998ad3140ba161843cf52fc0f01d8eb04dc105433e74f57e13dba" + }, + "Lean.Meta.Tactic.Symm": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Symm.olean", + "sha256": "9e576fa9ccc14f72a6d4b75f9ccb133f5463c531031fc0abcd81f9ce1e002b6b" + }, + "Lean.Meta.Tactic.Try": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Try.olean", + "sha256": "e2c566144935639f447b2493030d97204d22cfb866bd8c767ec0fba491cb56c2" + }, + "Lean.Meta.Tactic.Try.Collect": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Try/Collect.olean", + "sha256": "eb58abadce47d13437cc648de8c9c4d34965bde2b5b8c0fb5be46aa7c2f709bb" + }, + "Lean.Meta.Tactic.TryThis": { + "relative_path": "lib/lean/Lean/Meta/Tactic/TryThis.olean", + "sha256": "b0a43bfa4c21d9d9c9181de4783e7f7637862e6799dc17a94ffd41b6b8320535" + }, + "Lean.Meta.Tactic.Unfold": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Unfold.olean", + "sha256": "c512bf7a8ddc53bc480ed017efccdce73fa6a65ff3bc8026fcdb45108910a8f1" + }, + "Lean.Meta.Tactic.UnifyEq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/UnifyEq.olean", + "sha256": "17895f0232b1c9b37739a6678bc125d5481c4711fd70dcc2e0d7533d2ae7d88a" + }, + "Lean.Meta.Tactic.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Util.olean", + "sha256": "26f024806a3c5a844167cad452c161e17dd535f37c2f70f76fa8d0e98ac7d898" + }, + "Lean.Meta.Transform": { + "relative_path": "lib/lean/Lean/Meta/Transform.olean", + "sha256": "0fad85dd417e805f932c54eada13d21053a7457b9154026cf16b38e3458fc759" + }, + "Lean.Meta.TransparencyMode": { + "relative_path": "lib/lean/Lean/Meta/TransparencyMode.olean", + "sha256": "8f195daac0641aeeb14c47bb8989f99929ddb79329d5b64dd4349bc21ad52fdc" + }, + "Lean.Meta.UnificationHint": { + "relative_path": "lib/lean/Lean/Meta/UnificationHint.olean", + "sha256": "f6400a3713e4a9a72e4f2ef064ebe692706c0f21f186dce75250fe6eb4138a85" + }, + "Lean.Meta.WHNF": { + "relative_path": "lib/lean/Lean/Meta/WHNF.olean", + "sha256": "13939b1cdb2a81230a5445e9836dadeead92b5810b293c5da265451f02dd516f" + }, + "Lean.MetavarContext": { + "relative_path": "lib/lean/Lean/MetavarContext.olean", + "sha256": "616fb991aae42c8780c3566eadfe5e7cbabbf4779da1cf138014130772a668e1" + }, + "Lean.Modifiers": { + "relative_path": "lib/lean/Lean/Modifiers.olean", + "sha256": "34a8b59c7358c3a176430743f45ff649c47511e16e8b38bc763e3d63d82d11ae" + }, + "Lean.MonadEnv": { + "relative_path": "lib/lean/Lean/MonadEnv.olean", + "sha256": "086512b6ccf3afb524b665d93bfa512c8d2f699dd55ee4d59acab9376c379659" + }, + "Lean.Namespace": { + "relative_path": "lib/lean/Lean/Namespace.olean", + "sha256": "a4eb3519381836c10a0afd99e58a248135c277cd2a9489cc77636877914df692" + }, + "Lean.Parser": { + "relative_path": "lib/lean/Lean/Parser.olean", + "sha256": "28d395e6f52a72577be7747cfd60a84d5fef0edbff614963675e7103f43ce066" + }, + "Lean.Parser.Attr": { + "relative_path": "lib/lean/Lean/Parser/Attr.olean", + "sha256": "d37af508df519b54e878fdf29c6ff2006c4ab3d66c189302f2e28d50fb53d01e" + }, + "Lean.Parser.Basic": { + "relative_path": "lib/lean/Lean/Parser/Basic.olean", + "sha256": "948a51872ed931dcd069d6717532f02760ec64f1acfd6862fc5d222cc6aedeb0" + }, + "Lean.Parser.Command": { + "relative_path": "lib/lean/Lean/Parser/Command.olean", + "sha256": "a095b104d809b21d76722139623c677f932cbe8f33f79077c0f7469facaa4d21" + }, + "Lean.Parser.Do": { + "relative_path": "lib/lean/Lean/Parser/Do.olean", + "sha256": "0d97f39e5ec556f827c8399724fc2c7ad26b9b7a3aa8583158c1b335d2962edc" + }, + "Lean.Parser.Extension": { + "relative_path": "lib/lean/Lean/Parser/Extension.olean", + "sha256": "3d5387205b22b17b0449553339d1449481eb01d1f90424c1920521dfbbd6a51d" + }, + "Lean.Parser.Extra": { + "relative_path": "lib/lean/Lean/Parser/Extra.olean", + "sha256": "26993ef7f1b0dc107e5a54f5346becb1ed7df9e287a9716ba9a90dc25cb5597a" + }, + "Lean.Parser.Level": { + "relative_path": "lib/lean/Lean/Parser/Level.olean", + "sha256": "028076fe879c3d1f470248400637a3b2a404bd2807c6b1c42bd9f19b37a87385" + }, + "Lean.Parser.Module": { + "relative_path": "lib/lean/Lean/Parser/Module.olean", + "sha256": "1cd96b90357d48c1313be94c170a60e06deab7c2230a7684a5d3ad39a41a1453" + }, + "Lean.Parser.StrInterpolation": { + "relative_path": "lib/lean/Lean/Parser/StrInterpolation.olean", + "sha256": "1f275289f803e6362acbbdbb64dcbd1f4b63a25d01b96104d8bad7419712270a" + }, + "Lean.Parser.Syntax": { + "relative_path": "lib/lean/Lean/Parser/Syntax.olean", + "sha256": "b7d13deae25970c03965ab71ee15b6079948b4031f5c7877b19253d75b32a9a8" + }, + "Lean.Parser.Tactic": { + "relative_path": "lib/lean/Lean/Parser/Tactic.olean", + "sha256": "1d5f60bbb0520f7381c7942188f25406b178ed74e64c6995b8136e9d410617c9" + }, + "Lean.Parser.Tactic.Doc": { + "relative_path": "lib/lean/Lean/Parser/Tactic/Doc.olean", + "sha256": "de5fa176afd2efb06130e19b1fad85a782e8f6c70abd81e07410c06bdaaf435c" + }, + "Lean.Parser.Term": { + "relative_path": "lib/lean/Lean/Parser/Term.olean", + "sha256": "c27cd04030908ee1296d32a8230508cf878e37d3d9b55dc54a33dfd8f7bbcbaf" + }, + "Lean.Parser.Term.Doc": { + "relative_path": "lib/lean/Lean/Parser/Term/Doc.olean", + "sha256": "48344268b22b852d1c35ae1a717dcd804b7e02cb6619538b521a0f9f7c5b75ec" + }, + "Lean.Parser.Types": { + "relative_path": "lib/lean/Lean/Parser/Types.olean", + "sha256": "ebb9269d0c74ef1b84ed10af9a0fcfebd8c5f06af78ea8b7de52fab501ec3801" + }, + "Lean.ParserCompiler": { + "relative_path": "lib/lean/Lean/ParserCompiler.olean", + "sha256": "dfcf227a5095244c4f18259255e84b7d7486916a13d15cc7d494bf8327e7ea01" + }, + "Lean.ParserCompiler.Attribute": { + "relative_path": "lib/lean/Lean/ParserCompiler/Attribute.olean", + "sha256": "0635f545bec6dc4635f71024582d1e77d8ea6ace85b71d596c241b8c5cbb7ae0" + }, + "Lean.PremiseSelection": { + "relative_path": "lib/lean/Lean/PremiseSelection.olean", + "sha256": "84ad62edb54be2f55ea548421e59915503f678f5a689528429cbd6b3a47f52c3" + }, + "Lean.PrettyPrinter": { + "relative_path": "lib/lean/Lean/PrettyPrinter.olean", + "sha256": "f3c54ec68adb7b306e7de49fe6e1cc53c591053f6d772c125120e35cc0e42762" + }, + "Lean.PrettyPrinter.Basic": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Basic.olean", + "sha256": "5c155123ea1a5935403072f161006d3609e769fa5971cc83b99217c93d269a70" + }, + "Lean.PrettyPrinter.Delaborator": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator.olean", + "sha256": "2832e05f38fb87dd795cde9f6529793009807c6599a36ca0655f04eceb2c216c" + }, + "Lean.PrettyPrinter.Delaborator.Attributes": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Attributes.olean", + "sha256": "f98afcbf332723561b6d466a6c129844cdaff8b8f55e79f43a0040d1a0eb6a5c" + }, + "Lean.PrettyPrinter.Delaborator.Basic": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Basic.olean", + "sha256": "e402ce6c7c87da5752f1ec58b3032275db4ee722342a55bc118ac16ccb31b129" + }, + "Lean.PrettyPrinter.Delaborator.Builtins": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Builtins.olean", + "sha256": "02e8e2ec8a01f0eeba7212f5f3731bad7811680c44c03045391acd6222e8246a" + }, + "Lean.PrettyPrinter.Delaborator.FieldNotation": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.olean", + "sha256": "0fd7dac9c26de870462ff5c02bfa167ddba6d4b6f5616e9cd0849bf410997dc1" + }, + "Lean.PrettyPrinter.Delaborator.Options": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Options.olean", + "sha256": "83038fe17fe8486d5c2d49c942c60f40a56a857ea203991d52b0877f4c96ebdd" + }, + "Lean.PrettyPrinter.Delaborator.SubExpr": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/SubExpr.olean", + "sha256": "0d284ad4e40cc16bff17d232de10dee13bfa15b68eeda439218984488a864cef" + }, + "Lean.PrettyPrinter.Delaborator.TopDownAnalyze": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.olean", + "sha256": "ae6466c25b02f08e0b5fdfa1d2905b521de447c99ed580026aeaf3fcbac14d54" + }, + "Lean.PrettyPrinter.Formatter": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Formatter.olean", + "sha256": "348c5cf96f47b9c3b5d672b87913ac267d4c9f6ab5cc6e1e46757b9a4898470f" + }, + "Lean.PrettyPrinter.Parenthesizer": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Parenthesizer.olean", + "sha256": "d11ccf31a884b96dd8e7ce4a3d0be88ee37572282cc77235996eb06283ff9e1e" + }, + "Lean.PrivateName": { + "relative_path": "lib/lean/Lean/PrivateName.olean", + "sha256": "01331d62033f1a153ccfce0e26b19eec216989653b9170e09690f3f30017cd9e" + }, + "Lean.ProjFns": { + "relative_path": "lib/lean/Lean/ProjFns.olean", + "sha256": "b4e573e1214a33dfb17c70b252e55c42d56cbaa3ee3a02b620fc3cb238587772" + }, + "Lean.ReducibilityAttrs": { + "relative_path": "lib/lean/Lean/ReducibilityAttrs.olean", + "sha256": "4474586ad1da6481575424de924659c612a3e8c6b715ddf34fc26039d2e51e29" + }, + "Lean.Replay": { + "relative_path": "lib/lean/Lean/Replay.olean", + "sha256": "b99332f1e48cab089d45ecc5b6fadb71f95adb915b95ac7d5f513b8866b65d4e" + }, + "Lean.ReservedNameAction": { + "relative_path": "lib/lean/Lean/ReservedNameAction.olean", + "sha256": "c4c0b3460d35f4083a2459f232a0ff881e69092173963b6a671550a8640b3b41" + }, + "Lean.ResolveName": { + "relative_path": "lib/lean/Lean/ResolveName.olean", + "sha256": "1c5302ed5d1925a703364dbb22a84eb835a738d1073a1f576eafb4551b2f6863" + }, + "Lean.Runtime": { + "relative_path": "lib/lean/Lean/Runtime.olean", + "sha256": "f2c44c67f19cf22efd8c35ebb08d645de14a15341ce43055392e503f90c96ebf" + }, + "Lean.ScopedEnvExtension": { + "relative_path": "lib/lean/Lean/ScopedEnvExtension.olean", + "sha256": "a81bf05e51a27486ca11bb4b7f627a71278be383d69c04380886f8be0d7fd0fe" + }, + "Lean.Server": { + "relative_path": "lib/lean/Lean/Server.olean", + "sha256": "bbd9570762b5728fbeba1cd4fb6e1e63d0dc1e2f2b117cafd9e7fcae9bad7637" + }, + "Lean.Server.AsyncList": { + "relative_path": "lib/lean/Lean/Server/AsyncList.olean", + "sha256": "d9ecedd556a8565e22c4c4ef375e498bcf46cff541631685e3c6bb59da13ec06" + }, + "Lean.Server.CodeActions": { + "relative_path": "lib/lean/Lean/Server/CodeActions.olean", + "sha256": "1ffd438b12bf14992169052902dc91ff981fbffbd5b9d9dc3cd351afadf2d924" + }, + "Lean.Server.CodeActions.Attr": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Attr.olean", + "sha256": "21177a969ea2086c19c19a7d71a2d66acd666bfbd49c77dff89a2193ab911100" + }, + "Lean.Server.CodeActions.Basic": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Basic.olean", + "sha256": "3092af6beab4d2ccbcdc4d3c493887fbc61d2fd8c6507359d8dc81515af83350" + }, + "Lean.Server.CodeActions.Provider": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Provider.olean", + "sha256": "aca19e7414b6c15aa725debc884e06aa48515bc10f78bdac847e92a0d3355945" + }, + "Lean.Server.Completion": { + "relative_path": "lib/lean/Lean/Server/Completion.olean", + "sha256": "2d2b0e130132eee10776deb68540afbf5c588598b4f858be9850099e64e8039e" + }, + "Lean.Server.Completion.CompletionCollectors": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionCollectors.olean", + "sha256": "ca660a9b742f1e2f6adf50cc33847122c9bc017880a643d63a56053091cb9f8d" + }, + "Lean.Server.Completion.CompletionInfoSelection": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionInfoSelection.olean", + "sha256": "229a4e0e5238f4af4a9165f077e381a739b385a957ec1fe5590d0329711a221d" + }, + "Lean.Server.Completion.CompletionItemData": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionItemData.olean", + "sha256": "aa592a1060191b06553a282b4e2c23583260bbd32f193fdd82a2a0e3881b2ea5" + }, + "Lean.Server.Completion.CompletionResolution": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionResolution.olean", + "sha256": "1f1e99acc389c5ef5818bcc8c7c5e2a2ed0058e0be93661a2b2aaf6c4ccf3220" + }, + "Lean.Server.Completion.CompletionUtils": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionUtils.olean", + "sha256": "1b68673e815b0792013d12790d4bcf8768326df0b7ff0244cf27d3b1fb4603d7" + }, + "Lean.Server.Completion.EligibleHeaderDecls": { + "relative_path": "lib/lean/Lean/Server/Completion/EligibleHeaderDecls.olean", + "sha256": "f71255170c2f18efa266279cda6ec56942e0975689ccd22ec7eaaff127d8433b" + }, + "Lean.Server.Completion.ImportCompletion": { + "relative_path": "lib/lean/Lean/Server/Completion/ImportCompletion.olean", + "sha256": "aed78476c5e3c1d841563b30a1076e4d8392383fc0ba65273f50f96057bb3a5e" + }, + "Lean.Server.Completion.SyntheticCompletion": { + "relative_path": "lib/lean/Lean/Server/Completion/SyntheticCompletion.olean", + "sha256": "6d1733deb5c375a5d09f69a8719d6f0cd91659aac517071e22d50d8c1072d2ca" + }, + "Lean.Server.FileSource": { + "relative_path": "lib/lean/Lean/Server/FileSource.olean", + "sha256": "e28757c52a99267f3c788a9e83b0d30a1461d4113065f45444269fdf7b18f9ae" + }, + "Lean.Server.FileWorker": { + "relative_path": "lib/lean/Lean/Server/FileWorker.olean", + "sha256": "f6529233eb4cc58fd4ce7426ece4285e7b294fcd924f80e60759a609ce75ab4c" + }, + "Lean.Server.FileWorker.ExampleHover": { + "relative_path": "lib/lean/Lean/Server/FileWorker/ExampleHover.olean", + "sha256": "159199fc8757162b59d3e4882a5adde20b9d30f1e1c2e9d73f2d431d8225f8b2" + }, + "Lean.Server.FileWorker.InlayHints": { + "relative_path": "lib/lean/Lean/Server/FileWorker/InlayHints.olean", + "sha256": "a6a0a9f601e15e5f0a4f1a4c58cccfa47a090ddcea06b087cf4d35f83bc8acb8" + }, + "Lean.Server.FileWorker.RequestHandling": { + "relative_path": "lib/lean/Lean/Server/FileWorker/RequestHandling.olean", + "sha256": "bb4929eaa8e2895d7dede2dfcee916694296993384310e57cb44c2f207c769cb" + }, + "Lean.Server.FileWorker.SemanticHighlighting": { + "relative_path": "lib/lean/Lean/Server/FileWorker/SemanticHighlighting.olean", + "sha256": "18293c05d11ec7a4479e7139013a5da2244e92d2a15f6fe0683f5aa25910839c" + }, + "Lean.Server.FileWorker.SetupFile": { + "relative_path": "lib/lean/Lean/Server/FileWorker/SetupFile.olean", + "sha256": "6aadbc90fb133de6196241264b5e9199eb20873ac28c97fd525020b9d1ff8117" + }, + "Lean.Server.FileWorker.Utils": { + "relative_path": "lib/lean/Lean/Server/FileWorker/Utils.olean", + "sha256": "fb1141d854ddd8285b816247a29f6c73f55bdbb57598d5b23b5689b2dd5bc6b4" + }, + "Lean.Server.FileWorker.WidgetRequests": { + "relative_path": "lib/lean/Lean/Server/FileWorker/WidgetRequests.olean", + "sha256": "b6a3538e82fcf0053a603dd6b89dae5ac056f25833d5af7671d9f5730eccc0be" + }, + "Lean.Server.GoTo": { + "relative_path": "lib/lean/Lean/Server/GoTo.olean", + "sha256": "18aa8fbcc0ca8c945db6e6aa3eed8ed4ca27a7c9e08ba86af3f8be0828608cf4" + }, + "Lean.Server.InfoUtils": { + "relative_path": "lib/lean/Lean/Server/InfoUtils.olean", + "sha256": "77b7e95c6f553154b841639d2aa3bb24346e89434327ddcb557b5982e4de69de" + }, + "Lean.Server.References": { + "relative_path": "lib/lean/Lean/Server/References.olean", + "sha256": "de438915fcb962e19d09bfd1905df6632459853730bf416cbe9c1bcae4fe515f" + }, + "Lean.Server.RequestCancellation": { + "relative_path": "lib/lean/Lean/Server/RequestCancellation.olean", + "sha256": "cd8942ec9337da649a58c9f8ea7f01ecce2383c59e080f22116f48f386be3ee0" + }, + "Lean.Server.Requests": { + "relative_path": "lib/lean/Lean/Server/Requests.olean", + "sha256": "0ae37f883b90fbbbb165411871f2f1bf1cc6f166efca062dd8869f14c845c828" + }, + "Lean.Server.Rpc": { + "relative_path": "lib/lean/Lean/Server/Rpc.olean", + "sha256": "640216f0a569300668056ade5912685e2a0543328feba76d00a752859c3b692d" + }, + "Lean.Server.Rpc.Basic": { + "relative_path": "lib/lean/Lean/Server/Rpc/Basic.olean", + "sha256": "09a13a5b0eb1c751cf1689334e7d858d4db582a65bd458efd638a20153839f73" + }, + "Lean.Server.Rpc.Deriving": { + "relative_path": "lib/lean/Lean/Server/Rpc/Deriving.olean", + "sha256": "398279634e15fa8d0aa9394bc63d5ec59a867598db64d76e4772549ba8d29aec" + }, + "Lean.Server.Rpc.RequestHandling": { + "relative_path": "lib/lean/Lean/Server/Rpc/RequestHandling.olean", + "sha256": "0af5a93b3960757ec7bc913b866e9c8bb12a0d3d966d5701f526174d53342c8e" + }, + "Lean.Server.ServerTask": { + "relative_path": "lib/lean/Lean/Server/ServerTask.olean", + "sha256": "5b6e96d39b1fb04527dfe5efb97b1118c1947d723f31cac6c97f8815ad8624a5" + }, + "Lean.Server.Snapshots": { + "relative_path": "lib/lean/Lean/Server/Snapshots.olean", + "sha256": "0fc97604d59c24d8ee81fd5a63dc5ae1abbdc7f9d88e4cdb15eaaee0d0da0991" + }, + "Lean.Server.Test": { + "relative_path": "lib/lean/Lean/Server/Test.olean", + "sha256": "2afbefa351dbf1bcf23b5bfaad40f909905680ad39e528f867b4c463d3db58b1" + }, + "Lean.Server.Test.Cancel": { + "relative_path": "lib/lean/Lean/Server/Test/Cancel.olean", + "sha256": "f33dbeb8bdf19c481feee5ee16bae1d773e043a294995bd4a11f94f604b8771b" + }, + "Lean.Server.Test.Runner": { + "relative_path": "lib/lean/Lean/Server/Test/Runner.olean", + "sha256": "1c8d1946a902c7331616a9a9f7be3d8db6dd5bbe233698c23150fa37043b147d" + }, + "Lean.Server.Utils": { + "relative_path": "lib/lean/Lean/Server/Utils.olean", + "sha256": "c2a03554a131bed630c8b57d965b78c635062a6ac5d29086d801b76e9c3c1e5e" + }, + "Lean.Server.Watchdog": { + "relative_path": "lib/lean/Lean/Server/Watchdog.olean", + "sha256": "25bdfc1d26766745f8123b35795cf75cc03b3d067d7fa917d746a89972fa1081" + }, + "Lean.Structure": { + "relative_path": "lib/lean/Lean/Structure.olean", + "sha256": "1cce03c390b480c9ccfdc752f482f5772f9e8191a89ac2f92dbb371293edce08" + }, + "Lean.SubExpr": { + "relative_path": "lib/lean/Lean/SubExpr.olean", + "sha256": "56463ec2e047a75bc9582f7cba3698476c0595b80ad936524481c97edc7c57bb" + }, + "Lean.Syntax": { + "relative_path": "lib/lean/Lean/Syntax.olean", + "sha256": "1257d7730ef2a59134c6d3a66b812bd28464a93e906d80aa684118a2a2f7e41c" + }, + "Lean.ToExpr": { + "relative_path": "lib/lean/Lean/ToExpr.olean", + "sha256": "681106024aa58dff7c5dbea53ef9b5e01c166267413e6603fb59f7e6ba4705e4" + }, + "Lean.ToLevel": { + "relative_path": "lib/lean/Lean/ToLevel.olean", + "sha256": "0f1039c2e1e3a4e024294fe8827de0b83809ef22d6f95141a20f17bfd57010ed" + }, + "Lean.Util": { + "relative_path": "lib/lean/Lean/Util.olean", + "sha256": "b3804c0b6fd4187caaa395cdbf07b210634c36b5862e5b01e99a334894041ac5" + }, + "Lean.Util.CollectAxioms": { + "relative_path": "lib/lean/Lean/Util/CollectAxioms.olean", + "sha256": "9dd674224d00ea6e9044e05e9022d0997ed842b0eceee5157da199ea523614d3" + }, + "Lean.Util.CollectFVars": { + "relative_path": "lib/lean/Lean/Util/CollectFVars.olean", + "sha256": "03e91ed3ea63c86fa4a74f01eb026cba7a3c7a9a66e911f3420388bf0a24b06a" + }, + "Lean.Util.CollectLevelMVars": { + "relative_path": "lib/lean/Lean/Util/CollectLevelMVars.olean", + "sha256": "ee4f7731ff6e32e49c472ecc660fe70b7e8e28a9fe3e787d95968fc334cdafb9" + }, + "Lean.Util.CollectLevelParams": { + "relative_path": "lib/lean/Lean/Util/CollectLevelParams.olean", + "sha256": "f57df1551f35babfbd25cd4d786d36ca1c1e668a7dc733f1e86a7768a898c70e" + }, + "Lean.Util.CollectMVars": { + "relative_path": "lib/lean/Lean/Util/CollectMVars.olean", + "sha256": "1c5fc9f6e4a37382985419959a6a9e223763b770d78238e26e3b2029565d201e" + }, + "Lean.Util.Diff": { + "relative_path": "lib/lean/Lean/Util/Diff.olean", + "sha256": "348b407f6ab6b4cea1c17189e88ad4449669db50724e85bf333a7cd6eef01f8f" + }, + "Lean.Util.FVarSubset": { + "relative_path": "lib/lean/Lean/Util/FVarSubset.olean", + "sha256": "931302f6ee0fa3706536bf4c786d63c55903ee608fcfee3a7e62a884230b4689" + }, + "Lean.Util.FileSetupInfo": { + "relative_path": "lib/lean/Lean/Util/FileSetupInfo.olean", + "sha256": "fedeae0565096639cc7344c39c75dcd51760d451cf9e3bae3f67403fa3301420" + }, + "Lean.Util.FindExpr": { + "relative_path": "lib/lean/Lean/Util/FindExpr.olean", + "sha256": "fc9f82a261866735ac5f16c64903d5cd7ce354a5d559359f69e14c066299b82a" + }, + "Lean.Util.FindLevelMVar": { + "relative_path": "lib/lean/Lean/Util/FindLevelMVar.olean", + "sha256": "efa86d730a224bac9f9559414945fb8e4480adf9bd5c6f614bc386ccef4b79a8" + }, + "Lean.Util.FindMVar": { + "relative_path": "lib/lean/Lean/Util/FindMVar.olean", + "sha256": "f7c599d6b22db24fed3d4572b254ef1f625abbf242dc21a376a123913fbeaadd" + }, + "Lean.Util.FoldConsts": { + "relative_path": "lib/lean/Lean/Util/FoldConsts.olean", + "sha256": "30a5b555e3da24c6138cda39b0ce2fdd2898549424f3f48a5f0ad5a84a6ad024" + }, + "Lean.Util.ForEachExpr": { + "relative_path": "lib/lean/Lean/Util/ForEachExpr.olean", + "sha256": "f9b3a9c2bd938afe1ed5bfe2cdaac38da291c1f9cbc3ef00c6d70fe18c48b38c" + }, + "Lean.Util.ForEachExprWhere": { + "relative_path": "lib/lean/Lean/Util/ForEachExprWhere.olean", + "sha256": "0f66cc8ae514f42e32e37450023f5325c013a5f3b31cc00643b305ec2050a813" + }, + "Lean.Util.HasConstCache": { + "relative_path": "lib/lean/Lean/Util/HasConstCache.olean", + "sha256": "997838afe6cdc2068b866980bbc2d9571e08821ec262b3f96b5d182bda4d1e41" + }, + "Lean.Util.Heartbeats": { + "relative_path": "lib/lean/Lean/Util/Heartbeats.olean", + "sha256": "ef98dc435a31b539200931e89b2d3f08bd6e7f689e00ec3522ab1210b86e672d" + }, + "Lean.Util.InstantiateLevelParams": { + "relative_path": "lib/lean/Lean/Util/InstantiateLevelParams.olean", + "sha256": "f05e8a234de5794988814cab37b89a021d6e869311cd4fa372ab4f9ee2124424" + }, + "Lean.Util.LakePath": { + "relative_path": "lib/lean/Lean/Util/LakePath.olean", + "sha256": "dd00ea5edef5aeaf9d68948e3616d4de5052a4ac3e2acb67126898567f3fdb1b" + }, + "Lean.Util.LeanOptions": { + "relative_path": "lib/lean/Lean/Util/LeanOptions.olean", + "sha256": "036d4d32660acc69d0fc60938f15ea9ffa1edc7440340197d5d09dfbf7482e02" + }, + "Lean.Util.MonadBacktrack": { + "relative_path": "lib/lean/Lean/Util/MonadBacktrack.olean", + "sha256": "3a721336f768b1bd3d838101868b17bdcddb936acbe232601080cb47dae6bdef" + }, + "Lean.Util.MonadCache": { + "relative_path": "lib/lean/Lean/Util/MonadCache.olean", + "sha256": "a49bf6318c1fa4b7642ee350d0a0adfd5c9c30edfdbf5375bb08c27e89b9d09e" + }, + "Lean.Util.NumApps": { + "relative_path": "lib/lean/Lean/Util/NumApps.olean", + "sha256": "5e9a3b8f61219d6eb81d5e68ebf9783b3e653e6d2cad90d35d7fa1edaf48498d" + }, + "Lean.Util.NumObjs": { + "relative_path": "lib/lean/Lean/Util/NumObjs.olean", + "sha256": "1b6dcd0400b21b6478e0690faf12be333ac561dee8edf34fa9d940e0536d9c8d" + }, + "Lean.Util.OccursCheck": { + "relative_path": "lib/lean/Lean/Util/OccursCheck.olean", + "sha256": "2105d2cafdc97780ed80d0c21d96e3a96eb8c5b27c6f478ad8f511ff1d307a39" + }, + "Lean.Util.PPExt": { + "relative_path": "lib/lean/Lean/Util/PPExt.olean", + "sha256": "a5c502d22177658a419a532038b821f28cef4fa7a32e3c2544726ddd0b019c5e" + }, + "Lean.Util.Path": { + "relative_path": "lib/lean/Lean/Util/Path.olean", + "sha256": "75e708dc5859e0639e7eceae77d508a187db39ccb6cab080143e8dd26d4a0304" + }, + "Lean.Util.Paths": { + "relative_path": "lib/lean/Lean/Util/Paths.olean", + "sha256": "74142ed1f2181bb4102c8a0f6e41d41a4c658232937fc597f4e4b1c2a183b1bc" + }, + "Lean.Util.Profile": { + "relative_path": "lib/lean/Lean/Util/Profile.olean", + "sha256": "f23c4842d954d119e83de4dde14edb34981d6994cbeea4de9c2ae381f17bf831" + }, + "Lean.Util.Profiler": { + "relative_path": "lib/lean/Lean/Util/Profiler.olean", + "sha256": "1e9a3eec7c150b0e9ca1c785861eabb3f9a9c35a00d105c513439ec840a7ccbc" + }, + "Lean.Util.PtrSet": { + "relative_path": "lib/lean/Lean/Util/PtrSet.olean", + "sha256": "231e789db2045483e7600fec9903afba50dbba3e95c8c925982e2c1ea71b8a17" + }, + "Lean.Util.RecDepth": { + "relative_path": "lib/lean/Lean/Util/RecDepth.olean", + "sha256": "ea7a31d5424201f52482f7a9bf6de3ed5e0f8e741c131b78551fc6ac47b6b357" + }, + "Lean.Util.Recognizers": { + "relative_path": "lib/lean/Lean/Util/Recognizers.olean", + "sha256": "6ce3043ebd4aeb4bf7e43914580fc3fc414635d908d152ac393c283e07d0c2ce" + }, + "Lean.Util.ReplaceExpr": { + "relative_path": "lib/lean/Lean/Util/ReplaceExpr.olean", + "sha256": "aee2465ad5bf2bba0f52b8a4ea4b444990bcf68e15c7e32c387f31fb5a4606ec" + }, + "Lean.Util.ReplaceLevel": { + "relative_path": "lib/lean/Lean/Util/ReplaceLevel.olean", + "sha256": "bbdf8e6a5aa715de21a3edea51c9e0798e40fdffbd4896d15a3202d19e21bc21" + }, + "Lean.Util.SCC": { + "relative_path": "lib/lean/Lean/Util/SCC.olean", + "sha256": "f4ecd7303b846253b6aa74f4910f1c97089995e20ea654d78572898ea5ab764a" + }, + "Lean.Util.SafeExponentiation": { + "relative_path": "lib/lean/Lean/Util/SafeExponentiation.olean", + "sha256": "6ac2c719d74ffd8ec932fed7ea38541bb0bd64b1db68c15e143f1b31b7905a03" + }, + "Lean.Util.SearchPath": { + "relative_path": "lib/lean/Lean/Util/SearchPath.olean", + "sha256": "5c541f16a00ce65845346ff39f3e52602ba24873f9143b696ad31a35d0d0b174" + }, + "Lean.Util.ShareCommon": { + "relative_path": "lib/lean/Lean/Util/ShareCommon.olean", + "sha256": "041136336e252a66b1e09dbb0509423603f964469b9f41f34bb45cb47319683a" + }, + "Lean.Util.Sorry": { + "relative_path": "lib/lean/Lean/Util/Sorry.olean", + "sha256": "dc16c4717cb1b982328f48069d111d46ec937d63bf7648c94811c2ac7f8978a5" + }, + "Lean.Util.SortExprs": { + "relative_path": "lib/lean/Lean/Util/SortExprs.olean", + "sha256": "45a472f4dab7a0b1a22a2d5b07eac4e460c7a4471d49646f62e2d97d920faf6e" + }, + "Lean.Util.TestExtern": { + "relative_path": "lib/lean/Lean/Util/TestExtern.olean", + "sha256": "0c45aa686987702907d541dbe624dfb3b8c8389586d732fa05c9b86a53a96800" + }, + "Lean.Util.Trace": { + "relative_path": "lib/lean/Lean/Util/Trace.olean", + "sha256": "40e261ba920c89ca7a7573bfc699a3ac1e20983625025e2fc77a3aa8181a2c8f" + }, + "Lean.Widget": { + "relative_path": "lib/lean/Lean/Widget.olean", + "sha256": "82d3aaf72aaee748640ab3d5857f71623623455d4b4c7ac359f0f4e5e39a49f9" + }, + "Lean.Widget.Basic": { + "relative_path": "lib/lean/Lean/Widget/Basic.olean", + "sha256": "7b47ae225c065d669da84ca522e2dceb9a577e4bd7474d7377cf94d189a14ed9" + }, + "Lean.Widget.Diff": { + "relative_path": "lib/lean/Lean/Widget/Diff.olean", + "sha256": "6803e1c1d4d7de80fabd38cce68ecdabef3888f104d5b5bb17456a41a103ed6f" + }, + "Lean.Widget.InteractiveCode": { + "relative_path": "lib/lean/Lean/Widget/InteractiveCode.olean", + "sha256": "08dd8d5166eba1216188ec5a5b791c2e571805398fad6a4f0d1793026f063f54" + }, + "Lean.Widget.InteractiveDiagnostic": { + "relative_path": "lib/lean/Lean/Widget/InteractiveDiagnostic.olean", + "sha256": "a57b624487c0509b52919bf93ca49fd5006669cd87a28d7d1d6df05b7c121368" + }, + "Lean.Widget.InteractiveGoal": { + "relative_path": "lib/lean/Lean/Widget/InteractiveGoal.olean", + "sha256": "fe6f3299cefd00d81053c19c7a68a9140dd3c1199581807d18bc10212836b5b1" + }, + "Lean.Widget.TaggedText": { + "relative_path": "lib/lean/Lean/Widget/TaggedText.olean", + "sha256": "2231b307e81af9a860c445c61019110b50b2f7a147b20d4eff3a7aca896a495e" + }, + "Lean.Widget.Types": { + "relative_path": "lib/lean/Lean/Widget/Types.olean", + "sha256": "ec95be52006e362cdbab66493e159108d6b2803f7febb6f763d3e6ab58350a40" + }, + "Lean.Widget.UserWidget": { + "relative_path": "lib/lean/Lean/Widget/UserWidget.olean", + "sha256": "0e76215569ef9ba42148916c778a855b0eda47c384ffe95f40848401d3f7e77a" + }, + "Std": { + "relative_path": "lib/lean/Std.olean", + "sha256": "7d3771da25b893da62564bf8198487ff28f01af5cbd410be88d493a4921b2bb1" + }, + "Std.Classes.Ord": { + "relative_path": "lib/lean/Std/Classes/Ord.olean", + "sha256": "d951a4e6a043afe223eec3c1fc4ac05f4da95e923d7f9fa7438ccf1c4c5894e9" + }, + "Std.Data": { + "relative_path": "lib/lean/Std/Data.olean", + "sha256": "0c7214cfc515a6bd7d993a5a036a749d927911c61074e6f000b2f6e5c5e68437" + }, + "Std.Data.DHashMap": { + "relative_path": "lib/lean/Std/Data/DHashMap.olean", + "sha256": "82829a319d1dbc479d69cbeded2541fb6d4bea621843bcfb621dcddf66e3df4a" + }, + "Std.Data.DHashMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/DHashMap/AdditionalOperations.olean", + "sha256": "dcda48b215964eeb7adfdd6d8c898750cfdde669285b7e53559e844747be2e4f" + }, + "Std.Data.DHashMap.Basic": { + "relative_path": "lib/lean/Std/Data/DHashMap/Basic.olean", + "sha256": "3edd8593c538aa619f7a6a49b1201f895b2e195732067e9804cd1ec746ae0230" + }, + "Std.Data.DHashMap.Internal.AssocList.Basic": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Basic.olean", + "sha256": "cde6580d4017820217ba306c2850560e6c3820a22675b795bab7deee58fae39a" + }, + "Std.Data.DHashMap.Internal.AssocList.Lemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.olean", + "sha256": "89bb1625f83532972c2508e241727bd158ed8630437449d6dfb2409004029cca" + }, + "Std.Data.DHashMap.Internal.Defs": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Defs.olean", + "sha256": "b6789918a75b94e20a471fc1249196389b61a7bca005cb6e11868b9b2e0b2050" + }, + "Std.Data.DHashMap.Internal.HashesTo": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/HashesTo.olean", + "sha256": "df5a76c22a9d30d6067466a54454ffafb1d7a268ff2327e10d274d4b86bcb787" + }, + "Std.Data.DHashMap.Internal.Index": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Index.olean", + "sha256": "ca4d3761d5291eccc1f8238dafbe210fa5666c54a0a42c3e9b51acdcbe9d4900" + }, + "Std.Data.DHashMap.Internal.Model": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Model.olean", + "sha256": "dd3b5266f90bdc5e4cc8c5e9c1b65222671aaa830a5a23508f9fdb00fa6111c3" + }, + "Std.Data.DHashMap.Internal.Raw": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Raw.olean", + "sha256": "ab20c7d8f702c86de6cce3e18141f1297dea8d51a579460b0ddab9e278daf908" + }, + "Std.Data.DHashMap.Internal.RawLemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/RawLemmas.olean", + "sha256": "aa891b7b6476ead8295065dcd7df85e16c40e95a8a48c433d1e0c6ff8f58e9a7" + }, + "Std.Data.DHashMap.Internal.WF": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/WF.olean", + "sha256": "0d02c631912fd443890dd882c9035af450a64ded829c5613e29c6ad6d8690538" + }, + "Std.Data.DHashMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Lemmas.olean", + "sha256": "f5191f02349eb72c1ddb45074f9239912d9cd008a48a6cbabd76b2469d28d197" + }, + "Std.Data.DHashMap.Raw": { + "relative_path": "lib/lean/Std/Data/DHashMap/Raw.olean", + "sha256": "5ff8a7568a967e563bba428926cc128806c61ef2ecce021358984a45cff4c308" + }, + "Std.Data.DHashMap.RawDef": { + "relative_path": "lib/lean/Std/Data/DHashMap/RawDef.olean", + "sha256": "98e9e12f08790541143b32cfdaec3d0289209b1e770774dc01345116a7dddca4" + }, + "Std.Data.DHashMap.RawLemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/RawLemmas.olean", + "sha256": "514c964fac6f063724169db30add357a674ca243957dfa221e30430c26f06c92" + }, + "Std.Data.DTreeMap": { + "relative_path": "lib/lean/Std/Data/DTreeMap.olean", + "sha256": "51e3386cf7ba0a9f270c3a6d44af2ef5f6bac8fcffe8458cb7d3bba2edf610aa" + }, + "Std.Data.DTreeMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/DTreeMap/AdditionalOperations.olean", + "sha256": "a20b5c57a0db704748a2e2926dfa4d2cf1e4ddaefcc2245688970941c5ca8429" + }, + "Std.Data.DTreeMap.Basic": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Basic.olean", + "sha256": "26808eeb3d7d1e129af3a70fe13001b79dc74b18c7b406cb1373c7de98f62f56" + }, + "Std.Data.DTreeMap.Internal.Balanced": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Balanced.olean", + "sha256": "485264c582ccaaf76b6796dd881ccd1f6f61012f5d0c722fde5bd9a7b4310c70" + }, + "Std.Data.DTreeMap.Internal.Balancing": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Balancing.olean", + "sha256": "5263f1223026803115af0abbeeffdea7754796f215e6713aefc40c839b8353c1" + }, + "Std.Data.DTreeMap.Internal.Cell": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Cell.olean", + "sha256": "16fadb10f9bf8b6f4f20ec627775bdb827ff1f12c66b8e5f97c7e14b4a63ce98" + }, + "Std.Data.DTreeMap.Internal.Def": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Def.olean", + "sha256": "ad1d1e858fb304c03404a3003afefa2ab63634f240352448dbbe000fbc280ae7" + }, + "Std.Data.DTreeMap.Internal.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Lemmas.olean", + "sha256": "86f93dba7c263b8817d9a6e568d2a298b223b1dcf7a3bf63a21e04485d1e702e" + }, + "Std.Data.DTreeMap.Internal.Model": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Model.olean", + "sha256": "190a424ea72373859e33b93057f74fddfff1901c99020758c3b2a071893edcca" + }, + "Std.Data.DTreeMap.Internal.Operations": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Operations.olean", + "sha256": "02e3f14395f2e036d817076b3e901b7d186bd39c8b9e7204a1684faac1b5eaca" + }, + "Std.Data.DTreeMap.Internal.Ordered": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Ordered.olean", + "sha256": "bfd736cf4717c6dfd91e4764c030a2e35d7d80f24532ceccbb56924be30d3603" + }, + "Std.Data.DTreeMap.Internal.Queries": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Queries.olean", + "sha256": "4fb2bc063203c87f9db29252321a80602d0a7265647778abc9d22aaba5acbee7" + }, + "Std.Data.DTreeMap.Internal.WF.Defs": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Defs.olean", + "sha256": "899b439766bf2c13fba7b5ebfa6da9110b2e9f6e9ad9125c721d339332792432" + }, + "Std.Data.DTreeMap.Internal.WF.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.olean", + "sha256": "b6660199d8eaf0aaa0227cc92ef439c43914ff5f193983cb236d761212481a2a" + }, + "Std.Data.DTreeMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Lemmas.olean", + "sha256": "8f13b8ea4484f0112ac26021f999437da815203047e8d6dd398b3460616466bb" + }, + "Std.Data.DTreeMap.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Raw/Basic.olean", + "sha256": "d7ac0f19bdbd8fc3fbdeb86e07d5359234da8e0ead67247fb552613579747f6c" + }, + "Std.Data.HashMap": { + "relative_path": "lib/lean/Std/Data/HashMap.olean", + "sha256": "99aff9518169b47e1e93af220fb0526ff2a5ecaf538ff1bdd2962b6f2c8d4758" + }, + "Std.Data.HashMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/HashMap/AdditionalOperations.olean", + "sha256": "f7122016e852683cbe4b78252a5a0d334e31d8c583634068600988194a135753" + }, + "Std.Data.HashMap.Basic": { + "relative_path": "lib/lean/Std/Data/HashMap/Basic.olean", + "sha256": "6f76031eeeaa6d43db6e9c3a77c12f7811a80ac7d92b1538bd1b03c99e0588f6" + }, + "Std.Data.HashMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/HashMap/Lemmas.olean", + "sha256": "13da5f44c528a875968ebcab85fafb5cfc854b7f54fd4880ae6fbec2c8dd70d6" + }, + "Std.Data.HashMap.Raw": { + "relative_path": "lib/lean/Std/Data/HashMap/Raw.olean", + "sha256": "e22fdbb83c3274c85d0a292a3810c6408d134cf0d5e8bc0329f50777aee3e3f3" + }, + "Std.Data.HashMap.RawLemmas": { + "relative_path": "lib/lean/Std/Data/HashMap/RawLemmas.olean", + "sha256": "0a3c4d3b8e8d5ab3006148f6e227e5482da7199f8865c0c8dc762d07a13c71a8" + }, + "Std.Data.HashSet": { + "relative_path": "lib/lean/Std/Data/HashSet.olean", + "sha256": "ae45358a15acbf4ac5609305ab80d9ca42fa22cb4589f3c48c2a94a507250451" + }, + "Std.Data.HashSet.Basic": { + "relative_path": "lib/lean/Std/Data/HashSet/Basic.olean", + "sha256": "8bae54c3695a9aa1f51b76043d32ebbae9123b1a155605c54c1be2a899ce3385" + }, + "Std.Data.HashSet.Lemmas": { + "relative_path": "lib/lean/Std/Data/HashSet/Lemmas.olean", + "sha256": "29883ee4a5a8aceeef42dd000f1a3d682416b3668289b05afbb86cf3dbe7ed72" + }, + "Std.Data.HashSet.Raw": { + "relative_path": "lib/lean/Std/Data/HashSet/Raw.olean", + "sha256": "dc892a38a4976c064458b561027640cb3343c9661141c532c465f24bb635271d" + }, + "Std.Data.HashSet.RawLemmas": { + "relative_path": "lib/lean/Std/Data/HashSet/RawLemmas.olean", + "sha256": "ad52a319fb705c08ffd691126d42ee63e0e6a6caeb828114828cc2fe466f8db9" + }, + "Std.Data.Internal.Cut": { + "relative_path": "lib/lean/Std/Data/Internal/Cut.olean", + "sha256": "16e746f9da7b0e74567b1656a7e3f99cafc699acc54faed11bbe17a02d801060" + }, + "Std.Data.Internal.List.Associative": { + "relative_path": "lib/lean/Std/Data/Internal/List/Associative.olean", + "sha256": "fec662ce7c583a3d835d612b39ec478a6153c06e3b7de30a537cf6895f5bb093" + }, + "Std.Data.Internal.List.Defs": { + "relative_path": "lib/lean/Std/Data/Internal/List/Defs.olean", + "sha256": "56e8ec040898820fa1f1b9d807be6c96e4c44812b61c37b29ba4eb92199dbbc4" + }, + "Std.Data.TreeMap": { + "relative_path": "lib/lean/Std/Data/TreeMap.olean", + "sha256": "a1acd79ea550bcbeb8803a663d203d65c2ec5f3c528e1d3b20e6d84bba1f5818" + }, + "Std.Data.TreeMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/TreeMap/AdditionalOperations.olean", + "sha256": "7ff677628c427286ffa273bb5e733ba2b3c400ba4ac199377d8f354740bd90d5" + }, + "Std.Data.TreeMap.Basic": { + "relative_path": "lib/lean/Std/Data/TreeMap/Basic.olean", + "sha256": "01d1578d10e52b69cfa9a2ebc0dbbb16dd36a786deee2bdf44129b2672f67755" + }, + "Std.Data.TreeMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/TreeMap/Lemmas.olean", + "sha256": "c6b1f9d219326bf24700910e14066001120a278f007001bbf2a32dedd1af4006" + }, + "Std.Data.TreeMap.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/TreeMap/Raw/Basic.olean", + "sha256": "bc2fb5d7aa288ceb2d373f3c6a66c016a439cd1eb5560ba2a641e835064c833e" + }, + "Std.Data.TreeSet": { + "relative_path": "lib/lean/Std/Data/TreeSet.olean", + "sha256": "14078e4b78360b5431a4232dc911486455591bff1a3fad55f9155ae8c2ad7cac" + }, + "Std.Data.TreeSet.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/TreeSet/AdditionalOperations.olean", + "sha256": "86a8774587ec420050092ce6ba115aa9d379c59b491f55c815c062fdff15ce73" + }, + "Std.Data.TreeSet.Basic": { + "relative_path": "lib/lean/Std/Data/TreeSet/Basic.olean", + "sha256": "8f725039367c3acfe7a9de41011ce1bf66cb375fb16a0b4468d414c2f0ed5fc6" + }, + "Std.Data.TreeSet.Lemmas": { + "relative_path": "lib/lean/Std/Data/TreeSet/Lemmas.olean", + "sha256": "c436c982509e245de849ae7ca0a437b7f08eed26cd7a3eccc926763acd3fe9fe" + }, + "Std.Data.TreeSet.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/TreeSet/Raw/Basic.olean", + "sha256": "e970f9894439ef66418424f9d769c9e76de5ed0a6443c90dd821b482d715d015" + }, + "Std.Internal": { + "relative_path": "lib/lean/Std/Internal.olean", + "sha256": "450df0e4fd6e36bd632bccad2663e04b615dbba865e59de53815dd54bc5d3c1f" + }, + "Std.Internal.Async": { + "relative_path": "lib/lean/Std/Internal/Async.olean", + "sha256": "01ffdfd1f0410911338f8ef8b7e5f403d875b1a38ed01eac1953cd9c1659e3eb" + }, + "Std.Internal.Async.Basic": { + "relative_path": "lib/lean/Std/Internal/Async/Basic.olean", + "sha256": "77e5e714a1a50a1c66d738574d61b94729fa505d928f4041b479220c35f926d2" + }, + "Std.Internal.Async.TCP": { + "relative_path": "lib/lean/Std/Internal/Async/TCP.olean", + "sha256": "b8d4d89acab2bbb45c8f0ae41f0d43a9d1978efdbbf3cce9d21a8adbe977fbf2" + }, + "Std.Internal.Async.Timer": { + "relative_path": "lib/lean/Std/Internal/Async/Timer.olean", + "sha256": "df2a28402222a5529fe6c5d506b96d8b1a11a9a5722456590e77be97fe7bd59f" + }, + "Std.Internal.Async.UDP": { + "relative_path": "lib/lean/Std/Internal/Async/UDP.olean", + "sha256": "42aaaef54fd0324c3160d18901df6ab67d12c1392a5f7f79764e4b8ccdabef84" + }, + "Std.Internal.Parsec": { + "relative_path": "lib/lean/Std/Internal/Parsec.olean", + "sha256": "847cdbecf06faf5fc1ec0a8edbda87e56cae864215c3e5b0794e4487e52991e5" + }, + "Std.Internal.Parsec.Basic": { + "relative_path": "lib/lean/Std/Internal/Parsec/Basic.olean", + "sha256": "5043a60429010c81f150397f937633e38e59a4ebb0fedd362a3c4326d4c9e70c" + }, + "Std.Internal.Parsec.ByteArray": { + "relative_path": "lib/lean/Std/Internal/Parsec/ByteArray.olean", + "sha256": "b83f1320328c2ad431534ac41512842f4d99059c8ffce50cfad5c323f5d05bcb" + }, + "Std.Internal.Parsec.String": { + "relative_path": "lib/lean/Std/Internal/Parsec/String.olean", + "sha256": "d8fb53b268a2d7ca6b26a14028a6e2a396063d3c747373aca64f18bdafbcdd82" + }, + "Std.Internal.Rat": { + "relative_path": "lib/lean/Std/Internal/Rat.olean", + "sha256": "63e1219fe06b26b0022abcebc49b641a8726d1ffcb43650b6afcb61af71ef85e" + }, + "Std.Internal.UV": { + "relative_path": "lib/lean/Std/Internal/UV.olean", + "sha256": "510f7cfab3bf9547fe3bce0dd31453b8521ed3b7b25beeb16ee88bb088c90e60" + }, + "Std.Internal.UV.Loop": { + "relative_path": "lib/lean/Std/Internal/UV/Loop.olean", + "sha256": "732dc39b26fbc6027819191475f9aade211b5995be9036bf0babd80d2740d09e" + }, + "Std.Internal.UV.TCP": { + "relative_path": "lib/lean/Std/Internal/UV/TCP.olean", + "sha256": "dadd785a07060659ba22f37fcb6e17a06af3b6140d200e7d8f223ae7aaf928ad" + }, + "Std.Internal.UV.Timer": { + "relative_path": "lib/lean/Std/Internal/UV/Timer.olean", + "sha256": "57cee1e20bf5d037bcf6afe9720488ee00720e2deb2ce05d0445d4e097fc27b1" + }, + "Std.Internal.UV.UDP": { + "relative_path": "lib/lean/Std/Internal/UV/UDP.olean", + "sha256": "29d41d16510671c81a1df5b46e75f8c61c0ecce2ee5b35e53737bdc724022b2e" + }, + "Std.Net": { + "relative_path": "lib/lean/Std/Net.olean", + "sha256": "4c3e86bee81a4336a0aa64a3be9467a20b8b738bd1a8924ee4df82b980a0e4a2" + }, + "Std.Net.Addr": { + "relative_path": "lib/lean/Std/Net/Addr.olean", + "sha256": "21a68252d88ccc4e33691b2cab7aef5cc7cc8881c4e7a00e2154c4db8635492d" + }, + "Std.Sat": { + "relative_path": "lib/lean/Std/Sat.olean", + "sha256": "fcc29fb616396ddc2d3047d9b5c2f8dd3ad6239d727e06edfa2273e11f22109c" + }, + "Std.Sat.AIG": { + "relative_path": "lib/lean/Std/Sat/AIG.olean", + "sha256": "7c6aea2cf4f55d3ea5b3b4ae186869fcd416cb24fc5b1c797bf2aa511ced7207" + }, + "Std.Sat.AIG.Basic": { + "relative_path": "lib/lean/Std/Sat/AIG/Basic.olean", + "sha256": "97590c68ccbef54da03f6ea927368d999b560f594840a2c2c3899e52602a2a19" + }, + "Std.Sat.AIG.CNF": { + "relative_path": "lib/lean/Std/Sat/AIG/CNF.olean", + "sha256": "38e7324f561c93510b5b42466fc3b60be8372a46e0b872a45678fd6dc40c8495" + }, + "Std.Sat.AIG.Cached": { + "relative_path": "lib/lean/Std/Sat/AIG/Cached.olean", + "sha256": "f9b8e7536aaa9f2663fb19cbfddd1da6c0c9d1035b79ed5f71acea3ed76a913f" + }, + "Std.Sat.AIG.CachedGates": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedGates.olean", + "sha256": "a9fba0492584b3e3e537f181e626be94d5ff4d4f7cdfb6193d0ebfa59619fb03" + }, + "Std.Sat.AIG.CachedGatesLemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedGatesLemmas.olean", + "sha256": "e7637f2f0f2df05851138dc94f305c976aca8fbd121f648afae1b1be75edf072" + }, + "Std.Sat.AIG.CachedLemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedLemmas.olean", + "sha256": "4e8c65e9bc960950ea123ee30c9434b1e7a31955db5c6b118b5f6d1bf91b4151" + }, + "Std.Sat.AIG.If": { + "relative_path": "lib/lean/Std/Sat/AIG/If.olean", + "sha256": "0a976606263c24d96f678d34322b1172ee3ae1c1f50c9bc25274411b99ddbb21" + }, + "Std.Sat.AIG.LawfulOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/LawfulOperator.olean", + "sha256": "c8467c1aee8523a9b728ccf79988145304cada06f1da7eb80324db331aec8728" + }, + "Std.Sat.AIG.LawfulVecOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/LawfulVecOperator.olean", + "sha256": "2bcfabf0755288b3c3099a16e615e0e7e474c9b48e705ebee28137a46c4c6768" + }, + "Std.Sat.AIG.Lemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/Lemmas.olean", + "sha256": "0056f8de120614c48889fe5157b0fa5eb4e5caa87c1300a46d6f412268baf65d" + }, + "Std.Sat.AIG.RefVec": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVec.olean", + "sha256": "e8de7999a97a5390370aec10715a77d3abaf292a7df37a584c06e706458284ae" + }, + "Std.Sat.AIG.RefVecOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator.olean", + "sha256": "c07b62713579424613487ed5f40318b44cd5a30036959d23e9c7a39256c9474f" + }, + "Std.Sat.AIG.RefVecOperator.Fold": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Fold.olean", + "sha256": "8c65d0c2a25e424866314efd53a4edc08c2cd9da55edb76034538969fa3db5bc" + }, + "Std.Sat.AIG.RefVecOperator.Map": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Map.olean", + "sha256": "569cee3ddeb7b1b314354d0f051052bc4d21919d3948c06eeaba5da15f9dac96" + }, + "Std.Sat.AIG.RefVecOperator.Zip": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Zip.olean", + "sha256": "94244a0a8f0ce753f93b64831b56577cd9b8d68f9131b278281b77a3f2d43d44" + }, + "Std.Sat.AIG.Relabel": { + "relative_path": "lib/lean/Std/Sat/AIG/Relabel.olean", + "sha256": "fbdc72b958646b6206f8fd36cac01472e075dc69705f33947bbbef6614b6aa8b" + }, + "Std.Sat.AIG.RelabelNat": { + "relative_path": "lib/lean/Std/Sat/AIG/RelabelNat.olean", + "sha256": "8d7e0ea32786d8ce69c8605df88c666dbf8dee641c7945fde40e302ce7051a9d" + }, + "Std.Sat.CNF": { + "relative_path": "lib/lean/Std/Sat/CNF.olean", + "sha256": "a7ad1ae81e0305e03e2b6f3827101cde4cf4da0b64a59b3a25c038c4661ddc77" + }, + "Std.Sat.CNF.Basic": { + "relative_path": "lib/lean/Std/Sat/CNF/Basic.olean", + "sha256": "9fd3c6545ed9a1cb8b606df1749d7e40eb4eac6932fd19ad0efbbaaef98534d4" + }, + "Std.Sat.CNF.Dimacs": { + "relative_path": "lib/lean/Std/Sat/CNF/Dimacs.olean", + "sha256": "d35723222970cd0c95eccee2d1c8d94aef51ab955c1b8f35eb024fc395f664b4" + }, + "Std.Sat.CNF.Literal": { + "relative_path": "lib/lean/Std/Sat/CNF/Literal.olean", + "sha256": "86f2a80fe2c28b8e831989e13154f772a51fe820bca3ea61c5a542a56b0eef6d" + }, + "Std.Sat.CNF.Relabel": { + "relative_path": "lib/lean/Std/Sat/CNF/Relabel.olean", + "sha256": "e9bb76081b5ecf50ee4b6dd88e99f9cf405dc77574772c8645fd5f43d4310ec3" + }, + "Std.Sat.CNF.RelabelFin": { + "relative_path": "lib/lean/Std/Sat/CNF/RelabelFin.olean", + "sha256": "5b23bd94880be12c59a33437f57c82873234d547a0085a29c6dc4ca37f304ab2" + }, + "Std.Sync": { + "relative_path": "lib/lean/Std/Sync.olean", + "sha256": "6b122caecb73d049b18ea82b184696b04898758dea48f62c7e8b0ec17068c34f" + }, + "Std.Sync.Barrier": { + "relative_path": "lib/lean/Std/Sync/Barrier.olean", + "sha256": "0865e927b2d5c74eb1e762ef6043b19db015a3f7a16997392bdbe3405616c9e6" + }, + "Std.Sync.Basic": { + "relative_path": "lib/lean/Std/Sync/Basic.olean", + "sha256": "0ab37aae226de3c3c249e48eb99348220fd9239db043e8e70b00491ca7df6ffb" + }, + "Std.Sync.Channel": { + "relative_path": "lib/lean/Std/Sync/Channel.olean", + "sha256": "d263a7b5e81f7d062701d56c2f2940ec728e0b45d42ae29ac7ef5ad174b17a0f" + }, + "Std.Sync.Mutex": { + "relative_path": "lib/lean/Std/Sync/Mutex.olean", + "sha256": "28b1da9b8ad2e7873573ef3a394c20fbb1483b145dea927e22ae760913dfd30c" + }, + "Std.Sync.RecursiveMutex": { + "relative_path": "lib/lean/Std/Sync/RecursiveMutex.olean", + "sha256": "e270bb327da588a077b986c6683149f93c99ed2e43f2b80cdc79bf3255118fe5" + }, + "Std.Tactic": { + "relative_path": "lib/lean/Std/Tactic.olean", + "sha256": "bc4cb70f826910d0d63d5bb519966d715681e8fe8fb73913796d9c51c8530d7d" + }, + "Std.Tactic.BVDecide": { + "relative_path": "lib/lean/Std/Tactic/BVDecide.olean", + "sha256": "ec2db6253a2c5adbe13b53fdf97893e62022706a3a1604ade21af796ae949a17" + }, + "Std.Tactic.BVDecide.Bitblast": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast.olean", + "sha256": "faef1612ce3f38d3fa7978cf6b303d9876bbd43837dab7bfc0d7df30a42a1f86" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.olean", + "sha256": "36c4f0fd074cd62290da4cd5d0dd25b253108e7b37927836a2a68e24cbc62611" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.olean", + "sha256": "3fbf55b92e7fa7459b5626803a5c28693f10ae22bcc07dd0bbd5f9e52ddd5fc4" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.olean", + "sha256": "dc870f512d9db277c5e04837974578471b7aa8b6d7cd20c2e349c9f55776fde1" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.olean", + "sha256": "2bc70c17d6a23ed6d2b67e0fa0c46a2cde4b41fa6aec824dc64f609a81f8076b" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.olean", + "sha256": "28690113394104f6b0bf446e71254522b38e370ad8b4c48d2643c3c251f117c4" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.olean", + "sha256": "f831b1544b66b6c04562548d8ee3cd406faed9171e989001d235ca22489d93de" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.olean", + "sha256": "00399f76c92cefb3439614ef294998f337e72995b6279c7f3f57be5a182f3952" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.olean", + "sha256": "9fc172f017a8e08b3d373edb60be3aba9e3d82854acee27bb757e2052b7a073f" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.olean", + "sha256": "ba59db26788faeb05b026dd06ba5ddb8b39cb9169110413fa6ad5d65a1782f43" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.olean", + "sha256": "296f54c53ddf18f21dd6dbc6e279ba7256b944e35ed130570288d2fbc1bbafd3" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.olean", + "sha256": "4391a259589f6be7008648b4ab9eef743dc2b9a74f0f7dd4d631d534b8811e17" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.olean", + "sha256": "c87ee1a5d918eeda72930bbcf4889d9402a09bfe286b25012b06efac778dafbf" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.olean", + "sha256": "69116d9ffc41a4f37932d8cb3b4cea6592b9bda6f583df045b0f30ae0ec4a878" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.olean", + "sha256": "1c3439af37c32110c822bfee7afdf8b82289219f223e4475a61a2930876c270d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.olean", + "sha256": "bdae571ecb63fcd2e404c549d0233645f1d49daa257b854c03fdc672b11f25fe" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.olean", + "sha256": "6be36fe5e846df460b9cafdce7ce00525a16032b0f9957ef269429e4bc3235ce" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.olean", + "sha256": "2af3d46c89c1184b87d0499f08ae1364ede6b4d45a682ecc84a646c6ff37b590" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.olean", + "sha256": "59df5f0bdf0ab63f1d3a70c1ec428b51cd4d272aedd17ff6e69a47c8043eeb90" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.olean", + "sha256": "1c55bdc3550f4476aad8e2aabd64211d69c8993514758e2af3cc2251769b138e" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.olean", + "sha256": "f13b326a06e1000c0515520d0f4899e1aff23420f0e0e6ac5bba48a7a2061741" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.olean", + "sha256": "102946d64852967c3f451a662c10e0a548bec046e621e551b7dc467e4a0a2d7e" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.olean", + "sha256": "5f58293f58319935148d7a2bc68ad221ce9f5af0083862d72aece51381358100" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.olean", + "sha256": "5d0b577707c12577db272d62533ff29b2c37eca1ea425df4aaf104e74082ce1d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.olean", + "sha256": "0557dd76c0b555d978d97d7f04bc178ebb786d428871e4dd3cd73445f8bd2c39" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.olean", + "sha256": "81ba89dd877e8f5ecb4d79795d720bff671a1c226354759b28fab162f38e46ff" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.olean", + "sha256": "ebc829c16a69ba4601c7173f03eec5532020c0cff7ae92cd6dbcefd0368c2697" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.olean", + "sha256": "a4303ebf7a2e9d22270c2838e6240c06b563518adb9d4137349db1777b96ba86" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.olean", + "sha256": "3a8c2f39f7bf1f389bbd88e0e960d34ecf4b7af474a15d3669a397fe63a3b687" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.olean", + "sha256": "d67ad63ce049fe122cf9772ed2782555c6616ac326f67426e153f6cd5f5f31ea" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.olean", + "sha256": "308ad2bec762bc6ba6dd20c8a59466369dff6f12baed0014502ceb9af81f9128" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.olean", + "sha256": "c594d47b6dd7831dc6fbf18f337e4beb8cc317596d4da513c74cdd590b2aaa82" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.olean", + "sha256": "0e83560f33741e683d83de2c88d3b9bea126b818d4f9b947b6e2e60f3273793a" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.olean", + "sha256": "f4afff7bfa61967afcddcef49102e8aa6abfb46ac719f45fae9b2929995939df" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.olean", + "sha256": "57f9283128ba0708949930c0919ecadc22ec7b9d7e6b2dcdd7fad92a736afe0d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.olean", + "sha256": "35d396442771affa7630a0347396755620f9d042e8d489514dbefa2e5f3bd3ef" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.olean", + "sha256": "61ab83020b62ecea43b39fb36d24b2c6264f101c300bc53a020e29ac5cf23202" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.olean", + "sha256": "561125bbfaf3f343d17e25d37d77e43cfd0eaf6e21e0017cc9112929162d6628" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.olean", + "sha256": "cc8b989993b821ea578bb842b8da6c80522df6826b6d01238ca5adb568e449ac" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.olean", + "sha256": "d3072d202bf75c36371af08a4299d2982ad51392353d92d5011357964e3cd384" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.olean", + "sha256": "2be5439ac28922644312c8f8299059f81e58c79741d3a681a8a14a83457649ab" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.olean", + "sha256": "5b894fa82377d826b231e52d38987bf71fc1b10a92a7955fd18d9e5e5ebfe7ec" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.olean", + "sha256": "b2ac78762a87a6575421fda19f6576adf93e93f0b1af4b0ce49f55b8e9064463" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.olean", + "sha256": "0c5587d74b82923fd948c50d3da937bab12b86ec827d5e560c82b35bfa5c68fa" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.olean", + "sha256": "b95d38b7d0aabf70cb06123400e6ba0b94fd6073228b0eb5f55ab97d4428938a" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.olean", + "sha256": "789048c3011f067a8b8fba24630807fa03ce445f9e3dfac8c3528a4456603265" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.olean", + "sha256": "3dcc31a71f38e23ac8977a6e457302b32f5bcebde968012f3c33719e6b9c14f3" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.olean", + "sha256": "b5f8825d43310fb7f7333af20149f3064337396bafef7011d8af55c7f90380a5" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.olean", + "sha256": "8d9ff31e861a653c4998376235a1bfd1dcf760f05e1500f9867180cefd020d8b" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.olean", + "sha256": "10d1d3835811dde10bb29ad96b6c897780d8560198b0d04f28d1c3e4f4be1205" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.olean", + "sha256": "41ca8e8480c53c66991bf6dd267aa6bcd8d7c347942dec93d11b85f8d7224555" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.olean", + "sha256": "b2d68c645229bcfff4c1cb5d536e6acc7cb924ee954f9632198d5039280cd446" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.olean", + "sha256": "76828daa75f4568048da7ae525f1da9927112b9ea96ec22385387e2dcc0d1cbe" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.olean", + "sha256": "1a87afbf4654899ff46aed23db3f6ee24775b3113f551d4b1fb1e4e055b4968b" + }, + "Std.Tactic.BVDecide.Bitblast.BoolExpr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.olean", + "sha256": "3ab631e587fb4f4a5fc155f91d705d3ac544f98c75b22313db962ae0fcd9ba26" + }, + "Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.olean", + "sha256": "d441ce6550ac5d66fa7fed9d2f1b2e6a7207a0aa82d82da4ea372b2a4fad5526" + }, + "Std.Tactic.BVDecide.LRAT": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT.olean", + "sha256": "d355212d6f59c522d94e3c3dd34e3a02d74584f21270d3c75fd0f7b0fc1e6b23" + }, + "Std.Tactic.BVDecide.LRAT.Actions": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Actions.olean", + "sha256": "0077323c22e78b14dd46684d812da596c363a8f835ab47d9b7b429edcaf77c6f" + }, + "Std.Tactic.BVDecide.LRAT.Checker": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Checker.olean", + "sha256": "24cd2c42a4f2f34ecb83b2214194c9c808c7cc2ae49763f785d66911fb791e64" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Actions": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.olean", + "sha256": "6a8d16b5f258b9da457a8dae2729cf9cc8184ae3770c62c7767b60610d12cbf2" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Assignment": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.olean", + "sha256": "1dc4cf78bf8dd9093f22e8fb31fc2585a676096e1f92d8a169853e8c32e27868" + }, + "Std.Tactic.BVDecide.LRAT.Internal.CNF": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.olean", + "sha256": "5b09536fadc7ad28c0597d86a2926cc69397fbf93011a53ec07f3bc5d8144527" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Clause": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.olean", + "sha256": "c0ee4492b32ab35324ba3aa234288a517bbfd1a057b55a12b5587579dc8de5e4" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Convert": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.olean", + "sha256": "644f9516699727499c6bbf434dc411c7e32be39727c27df9fcf4ac4bc7885dfd" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Entails": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.olean", + "sha256": "555bd01a87e35f742a6784327cb0e15caa4b4589fdcb23b7d156612c8359aa60" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.olean", + "sha256": "e402782d59c498b9098addaf51b65c2a1f76015a3626d11ab150c7f8e4525e3c" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Class": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.olean", + "sha256": "61faf33007eb81ff1ba8c12c4829d6b8353b52580d1ae32216c5acce24117930" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.olean", + "sha256": "d8d956c48977e92718e15f51f3ed0e37b2523e84129f48c93d738a5ecc73e598" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.olean", + "sha256": "02dc2826a248aba00b4ff538bf73d1e84a1d26cb6bd86878e9aeaf96911578ea" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.olean", + "sha256": "326b363db75185b4e385f6d5ed25e3bc52249695cd47e96f7291b2befc17d99d" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.olean", + "sha256": "c8ae044e3f0cbfbdd16a5c8776c5bb505b8edecd7caa7227ac3e268f8e5a813b" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.olean", + "sha256": "f4639e7f4ce1257677cb3ef954622a378c51facaa49d1c2033d655a0429854ee" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.olean", + "sha256": "3db7edc84442cd86d9688f0259a59868e76ed0759f2d86dd35da5b8e928fecb5" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.olean", + "sha256": "7584cffd13ae359e9c7ef8edaea45c6d0233fbdcee5d80ee57aa9ac5284af5ce" + }, + "Std.Tactic.BVDecide.LRAT.Internal.LRATChecker": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.olean", + "sha256": "adad26830176d3fbb2cbd64c83197f5083e196b2a2651ee8d7194512724770da" + }, + "Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.olean", + "sha256": "b21dfacd5f2e5488e49885bfcf7de9deeb429a3c12a9a5d595f9f118372e8f90" + }, + "Std.Tactic.BVDecide.LRAT.Internal.PosFin": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.olean", + "sha256": "c9064ca9acae028a144600c48c49583991419d743274fc91d3bc6033e5f647a5" + }, + "Std.Tactic.BVDecide.LRAT.Parser": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Parser.olean", + "sha256": "99c91ddf2e3209427989057505c6db8ae009b0b66473add1123091e82eae22d5" + }, + "Std.Tactic.BVDecide.Normalize": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize.olean", + "sha256": "5a32966bb5d1d044ebbfa16701971c19613410077471fd78907932d23ac9d896" + }, + "Std.Tactic.BVDecide.Normalize.BitVec": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/BitVec.olean", + "sha256": "9a5419dace60a2336218c9900ccc2ba5b1740ee3ad3395204c1db96e2ee1265a" + }, + "Std.Tactic.BVDecide.Normalize.Bool": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Bool.olean", + "sha256": "e4a7ad5bb1aa46632d4f53c2e534df650adbab5d2299ab05f9357bf814568c02" + }, + "Std.Tactic.BVDecide.Normalize.Canonicalize": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.olean", + "sha256": "42efde7852aa32bfb49a2096a017f1acc3de2be1843f9a766fc33a2e8dba6ec9" + }, + "Std.Tactic.BVDecide.Normalize.Equal": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Equal.olean", + "sha256": "b811a7a95c0f5e441dfc6b4cefb0eec03e237442d2c57224fa4cf498436be742" + }, + "Std.Tactic.BVDecide.Normalize.Prop": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Prop.olean", + "sha256": "299264cac5f784ffcb12d7ec211033cf7913c4470e7ff363ade0cbbd2f18ea9a" + }, + "Std.Tactic.BVDecide.Reflect": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Reflect.olean", + "sha256": "6fa2f9828a59c1674437bee299f112a673ce7a30add77784b2bb610b6fdb50c6" + }, + "Std.Tactic.BVDecide.Syntax": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Syntax.olean", + "sha256": "0359dc3655c79f41a47af4d3c87485f738b79ac032d59738bbf48e16027416ba" + }, + "Std.Time": { + "relative_path": "lib/lean/Std/Time.olean", + "sha256": "0789687baa3558734be38cc4d152d748e9c6d2edf399507a1976246ce1db15d9" + }, + "Std.Time.Date": { + "relative_path": "lib/lean/Std/Time/Date.olean", + "sha256": "cb70aed3ccf7127c906dcab116c95c522aecb3987140814941c84eae42bf3f2a" + }, + "Std.Time.Date.Basic": { + "relative_path": "lib/lean/Std/Time/Date/Basic.olean", + "sha256": "f307e1a552373d28301792b5ca8bd0110b8e9d93eb81575689fbe3efd52b7ed8" + }, + "Std.Time.Date.PlainDate": { + "relative_path": "lib/lean/Std/Time/Date/PlainDate.olean", + "sha256": "9e9df12ccb5c285114cfdcf4039a2a021614747c9c45ccb6995722d248ddf3bb" + }, + "Std.Time.Date.Unit.Basic": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Basic.olean", + "sha256": "a073a7513d6b1fd55d88c56f341a3db71a933ee0563334e869db0e51618648f7" + }, + "Std.Time.Date.Unit.Day": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Day.olean", + "sha256": "5ebf7bb099376860bc2f18e7301dc33b2fba23a8de092dfa4ccc540a607edb1f" + }, + "Std.Time.Date.Unit.Month": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Month.olean", + "sha256": "795840aeee04727bd136c09d6f7c57c5eab32967bc5baa642caa071700d6f5ba" + }, + "Std.Time.Date.Unit.Week": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Week.olean", + "sha256": "1af7b14f7241b1157f7ede0be10b1ce8f84d59629fe9256ef2853f93f9920d10" + }, + "Std.Time.Date.Unit.Weekday": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Weekday.olean", + "sha256": "58a27e1054c0f7083540030928455a2f7f89568fd4df27904a992312e540431a" + }, + "Std.Time.Date.Unit.Year": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Year.olean", + "sha256": "1429b88657ba6078d953466050ae379a2c0ad32f908e64d3791b3f91271ab506" + }, + "Std.Time.Date.ValidDate": { + "relative_path": "lib/lean/Std/Time/Date/ValidDate.olean", + "sha256": "ace3749ecca5141ab1d66312455cbc165abe4a5e2a92e99181bdcab5a45dcaf8" + }, + "Std.Time.DateTime": { + "relative_path": "lib/lean/Std/Time/DateTime.olean", + "sha256": "bace36aa9c50b519ee6e46e6489fdfe349e77b3f7f00e952b8ddc54361639811" + }, + "Std.Time.DateTime.PlainDateTime": { + "relative_path": "lib/lean/Std/Time/DateTime/PlainDateTime.olean", + "sha256": "1296dc0c67ac54dbc5d0b1977fcfff082655daaea079ba088c070cdc4890924c" + }, + "Std.Time.DateTime.Timestamp": { + "relative_path": "lib/lean/Std/Time/DateTime/Timestamp.olean", + "sha256": "b4cd23a2f4ea4c96f2df2b83cfc655d0e19bef0238f6c044bf37b417faeb8756" + }, + "Std.Time.Duration": { + "relative_path": "lib/lean/Std/Time/Duration.olean", + "sha256": "768a81cc06f2a7b70728d660889a4e243f0fcfcf9270cdf735c7f95a26775a81" + }, + "Std.Time.Format": { + "relative_path": "lib/lean/Std/Time/Format.olean", + "sha256": "8d0928fbefb93f6de1f46e7e622f86beadb3e27115a29880eb0745b6fd74b7d4" + }, + "Std.Time.Format.Basic": { + "relative_path": "lib/lean/Std/Time/Format/Basic.olean", + "sha256": "23d409ed591814fd515cfb89781c282bf1990635241a8dac0fe4aa40668ce135" + }, + "Std.Time.Internal": { + "relative_path": "lib/lean/Std/Time/Internal.olean", + "sha256": "aecafe702fdd9d7c770b6b7d4d1843616ed03470014b13ea1ffc0d376c8091f0" + }, + "Std.Time.Internal.Bounded": { + "relative_path": "lib/lean/Std/Time/Internal/Bounded.olean", + "sha256": "49de757e44969f7b58b61b2218ba797db7d82682f64e272a249ffa13cec52d06" + }, + "Std.Time.Internal.UnitVal": { + "relative_path": "lib/lean/Std/Time/Internal/UnitVal.olean", + "sha256": "2293196364e88707f8cb1d82e99a18f155630a82a60f1ea6399f0144fdb6ef3f" + }, + "Std.Time.Notation": { + "relative_path": "lib/lean/Std/Time/Notation.olean", + "sha256": "9e9cd56d4bb18752d074d9a5545677bf880510f07038ad29595c0d88754b21c0" + }, + "Std.Time.Notation.Spec": { + "relative_path": "lib/lean/Std/Time/Notation/Spec.olean", + "sha256": "a08aada50626422dffd9168eccc354a0dda7769fc33d943c48d5c6dbeba380dd" + }, + "Std.Time.Time": { + "relative_path": "lib/lean/Std/Time/Time.olean", + "sha256": "aaa5e2da3807c23c60e80153e6a683af0835a58d89805dfb52cf9cfcdd09599b" + }, + "Std.Time.Time.Basic": { + "relative_path": "lib/lean/Std/Time/Time/Basic.olean", + "sha256": "08e7ff82d05c4f4aa49fc9b0702a1d499f31334df58a4dd693c92cf1860f50e8" + }, + "Std.Time.Time.HourMarker": { + "relative_path": "lib/lean/Std/Time/Time/HourMarker.olean", + "sha256": "be5bbcafbc86d200ae38d3681fa62eb89c5f92e54e658ce926f535a4ea5b7821" + }, + "Std.Time.Time.PlainTime": { + "relative_path": "lib/lean/Std/Time/Time/PlainTime.olean", + "sha256": "c341b0c38877ca56f7b8b758947b2e4cbe2cc5818286d78c4cb7d7f08fe60580" + }, + "Std.Time.Time.Unit.Basic": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Basic.olean", + "sha256": "d9802ce1313c896333ee3ad31889057c81f13bd40510da853d711018eb82deee" + }, + "Std.Time.Time.Unit.Hour": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Hour.olean", + "sha256": "cd26a34fd6964178efcfa29c86f9f240bb61dd601ec6e8a4daaa4fa1aeae1085" + }, + "Std.Time.Time.Unit.Millisecond": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Millisecond.olean", + "sha256": "f276ecae1131a214858236a4e6e3f495fc7e01d551d3b0bfa98c18301dea92f2" + }, + "Std.Time.Time.Unit.Minute": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Minute.olean", + "sha256": "7c9dc59498474221677908f899f8f8b98ccc4bcb9ced0a76b4b73608e03d1cb6" + }, + "Std.Time.Time.Unit.Nanosecond": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Nanosecond.olean", + "sha256": "6bc08672ed7d3e38d0343ce320ae09b2022fe6dab7e13c589dd11a12f6761147" + }, + "Std.Time.Time.Unit.Second": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Second.olean", + "sha256": "19a8c2259f0d51723c508d313c5d2da2896a5af464e9d6c809e047a772d49969" + }, + "Std.Time.Zoned": { + "relative_path": "lib/lean/Std/Time/Zoned.olean", + "sha256": "84ada81b95c5f170f68d7d2ec234bd3d007ad45d18364e531e5307f2c4d32617" + }, + "Std.Time.Zoned.Database": { + "relative_path": "lib/lean/Std/Time/Zoned/Database.olean", + "sha256": "5a324870d1bb5c102a79717c53840bb87ebbe4c7afb03499a31fb7aa51e04e8f" + }, + "Std.Time.Zoned.Database.Basic": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/Basic.olean", + "sha256": "76d13490a9d782e3c2616634c1d450f81d7978f836d5b7e6969361297a0287c9" + }, + "Std.Time.Zoned.Database.TZdb": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/TZdb.olean", + "sha256": "3345c6282c8805f291bfe6a6c219d4f8d21a2ab8aff2ad46e169aa33c073f777" + }, + "Std.Time.Zoned.Database.TzIf": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/TzIf.olean", + "sha256": "8fe12d507111f7ec04b7d1594959d190604da5bb3a0d944101472cedc2f4da02" + }, + "Std.Time.Zoned.Database.Windows": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/Windows.olean", + "sha256": "50d1a55ee0a71ddf05198a448f019c2bab95dab5d0e930157c220b8d349cbbdd" + }, + "Std.Time.Zoned.DateTime": { + "relative_path": "lib/lean/Std/Time/Zoned/DateTime.olean", + "sha256": "d313bdaf5fdefdc120eb57b5736d495d60ff33febf26db330e1fd99a7a2c396c" + }, + "Std.Time.Zoned.Offset": { + "relative_path": "lib/lean/Std/Time/Zoned/Offset.olean", + "sha256": "41d7f3f24b83359a4da791ff9d6e390bc19a09d0335086be6ac37b809ec75e5b" + }, + "Std.Time.Zoned.TimeZone": { + "relative_path": "lib/lean/Std/Time/Zoned/TimeZone.olean", + "sha256": "406fac44af49c5324d4857665a38f696fe47a0c15fbca5b458279e1c4a32c39e" + }, + "Std.Time.Zoned.ZoneRules": { + "relative_path": "lib/lean/Std/Time/Zoned/ZoneRules.olean", + "sha256": "86b9ebb4ce064c7f5c68fe3933a99d30e53d74c0a967669b7f23baffe77a4f1a" + }, + "Std.Time.Zoned.ZonedDateTime": { + "relative_path": "lib/lean/Std/Time/Zoned/ZonedDateTime.olean", + "sha256": "22285b4d4b6851745f3ba5b2fb79d739eb3000deebcc2ccdfbedec637ee53cd8" + } +} diff --git a/formal/sonification/mat009/audit/checker_mutant_driver.py b/formal/sonification/mat009/audit/checker_mutant_driver.py new file mode 100644 index 0000000..58808af --- /dev/null +++ b/formal/sonification/mat009/audit/checker_mutant_driver.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python3 +"""Exercise the complete checker against an isolated mutated proof module.""" + +from __future__ import annotations + +import importlib +import sys +from pathlib import Path +from unittest.mock import patch + +ROOT = Path(__file__).resolve().parents[4] +sys.path.insert(0, str(ROOT)) + +check = importlib.import_module("formal.sonification.mat009.lean.check") + + +def main() -> int: + work = Path(sys.argv[1]).resolve() + out = Path(sys.argv[2]).resolve() + argv = [ + "check.py", + "--lean", + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--baseline-commit", + "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "--out", + str(out), + ] + with patch.object(check, "HERE", work), patch.object(sys, "argv", argv): + return check.main() + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/formal/sonification/mat009/audit/count_gate.stderr b/formal/sonification/mat009/audit/count_gate.stderr new file mode 100644 index 0000000..3c4b72a --- /dev/null +++ b/formal/sonification/mat009/audit/count_gate.stderr @@ -0,0 +1,10 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/count_gate_driver.py", line 26, in + sys.exit(main()) + ~~~~^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/count_gate_driver.py", line 21, in main + check.audit_output(raw, LEAN, AUDIT) + ~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/check.py", line 145, in audit_output + raise ValueError("complete declaration/theorem inventory changed") +ValueError: complete declaration/theorem inventory changed diff --git a/formal/sonification/mat009/audit/count_gate.stdout b/formal/sonification/mat009/audit/count_gate.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/count_gate_driver.py b/formal/sonification/mat009/audit/count_gate_driver.py new file mode 100644 index 0000000..6a2de84 --- /dev/null +++ b/formal/sonification/mat009/audit/count_gate_driver.py @@ -0,0 +1,26 @@ +#!/usr/bin/env python3 +"""Feed the auxiliary-name mutant's original Lean log to the fixed-count gate.""" + +from __future__ import annotations + +import importlib +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[4] +sys.path.insert(0, str(ROOT)) +check = importlib.import_module("formal.sonification.mat009.lean.check") +AUDIT = Path(__file__).resolve().parent +LEAN = Path("/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean") + + +def main() -> int: + raw = ( + AUDIT / "negative-probe-001/auxiliary_named_false_axiom/build-04-LeanAudit.stdout" + ).read_bytes() + check.audit_output(raw, LEAN, AUDIT) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/formal/sonification/mat009/audit/independent-cpython-001.json b/formal/sonification/mat009/audit/independent-cpython-001.json new file mode 100644 index 0000000..87d1f55 --- /dev/null +++ b/formal/sonification/mat009/audit/independent-cpython-001.json @@ -0,0 +1,28 @@ +{ + "builtin_same_text_reason_count": 7, + "clean_reasons": [], + "clean_status": "STRUCTURAL_ONLY_UNAUTHENTICATED", + "cpython_refinement": "OPEN", + "dict_subclass_exception": "RuntimeError", + "invalid_role_reasons": [ + "TRAIN_REQUIRES_BOTH_PHASES", + "UNDECLARED_TRAIN_HOLDOUT_ROLE" + ], + "parent_skip_reasons": [ + "BOTH_PHASES_REQUIRED_FOR_EACH_CAMPAIGN", + "MISSING_OR_INVALID_SOURCE_IDENTITIES" + ], + "physical_evidence_admitted": false, + "source_sha256": { + "mat_spec_008.py": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", + "mat_spec_009.py": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690" + }, + "status": "PASS_FOR_LISTED_CASES_ONLY", + "subclass_equal_text_unequal_hash_reasons": [], + "synthetic_control_count": 14, + "synthetic_integer_one_reasons": [], + "synthetic_true_reasons": [ + "SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT" + ], + "unhashable_string_exception": "TypeError" +} diff --git a/formal/sonification/mat009/audit/independent-replay-001/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/independent-replay-001/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent-replay-001/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/independent-replay-001/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent-replay-001/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/independent-replay-001/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent-replay-001/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/independent-replay-001/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent-replay-001/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/independent-replay-001/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent-replay-001/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/independent-replay-001/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/independent-replay-001/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/independent-replay-001/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent-replay-001/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/independent-replay-001/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent-replay-001/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/independent-replay-001/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent-replay-001/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/independent-replay-001/build-04-LeanAudit.stdout new file mode 100644 index 0000000..cbccb8f --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/build-04-LeanAudit.stdout @@ -0,0 +1,1664 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.initial","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._closed_1._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.initial._elambda_1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.initial.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_3","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_4","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRow","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._closed_1._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.lastRole [] x = none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_2._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.leakageReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.leakageReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.noParent","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.noParent x = False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.noParent.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout ∧\n s.campaigns MAT009.Role.train \"SAME\" ∧ s.campaigns MAT009.Role.holdout \"SAME\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.overwrite_retains_both_split_memberships","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason ∧ ¬(MAT009.finalize s).childReason MAT009.leakageReason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_can_supply_leakage_reason","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (reason : String), s.parent reason → (MAT009.finalize s).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_reason_survives_finalization","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.scan s [] = s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_append","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key ↔\n s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), s.crossed → (MAT009.scan s rows).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_crossed_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.scan s rows)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_familyLeakage_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key ↔ s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_owner_last","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason ↔ s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.Role → String → Prop) → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.splitIntersection","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (members : MAT009.Role → String → Prop),\n MAT009.splitIntersection members = ∃ key, members MAT009.Role.train key ∧ members MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.splitIntersection.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.step","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.step._elambda_1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key ∨ role = row.role ∧ key = row.campaign,\n labs := fun role key => s.labs role key ∨ role = row.role ∧ key = row.lab,\n crossed := s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role,\n parent := s.parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.step.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String × MAT009.Diagnostic.Owner)) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (x : String) (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_15._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_16._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_17._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_18._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_19._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_20._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_21._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_AUDIT declarations=351 theorems=95 diff --git a/formal/sonification/mat009/audit/independent-replay-001/independent-axioms.json b/formal/sonification/mat009/audit/independent-replay-001/independent-axioms.json new file mode 100644 index 0000000..7b2a5dc --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/independent-axioms.json @@ -0,0 +1,74 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Consumer.shared_campaign_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Diagnostic.first_owner_not_last_writer": [ + "propext" + ], + "MAT009.Diagnostic.register_first_owner": [ + "propext" + ], + "MAT009.Diagnostic.register_new_owner": [ + "propext" + ], + "MAT009.Diagnostic.register_other_identity": [ + "propext" + ], + "MAT009.Diagnostic.register_preserves_existing": [ + "propext" + ], + "MAT009.Diagnostic.scan_first_owner_sticky": [ + "propext" + ], + "MAT009.M009_R1_initial": [ + "propext" + ], + "MAT009.M009_R2_assignment_overwrite": [ + "propext" + ], + "MAT009.M009_R3_cross_role_trigger": [], + "MAT009.M009_R4_stickiness": [], + "MAT009.M009_R5_final_set_intersection": [ + "propext" + ], + "MAT009.M009_R5_parent_union": [ + "propext" + ], + "MAT009.M009_R6_arbitrary_finite_scan": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_cross_trigger_in_finite_scan": [ + "propext" + ], + "MAT009.M009_R6_final_leakage_iff": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_latest_owner": [ + "propext" + ], + "MAT009.M009_R6_parent_reason_survives": [], + "MAT009.M009_R7_accepted_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_nonvacuous": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_rejected_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ] +} diff --git a/formal/sonification/mat009/audit/independent-replay-001/independent-axioms.stderr b/formal/sonification/mat009/audit/independent-replay-001/independent-axioms.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent-replay-001/independent-axioms.stdout b/formal/sonification/mat009/audit/independent-replay-001/independent-axioms.stdout new file mode 100644 index 0000000..31c7dc9 --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/independent-axioms.stdout @@ -0,0 +1,22 @@ +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.register_first_owner' depends on axioms: [propext] +'MAT009.Diagnostic.register_new_owner' depends on axioms: [propext] +'MAT009.Diagnostic.register_other_identity' depends on axioms: [propext] +'MAT009.Diagnostic.register_preserves_existing' depends on axioms: [propext] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/independent-replay-001/lean-version.stderr b/formal/sonification/mat009/audit/independent-replay-001/lean-version.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent-replay-001/lean-version.stdout b/formal/sonification/mat009/audit/independent-replay-001/lean-version.stdout new file mode 100644 index 0000000..507e58d --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/lean-version.stdout @@ -0,0 +1 @@ +Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release) diff --git a/formal/sonification/mat009/audit/independent-replay-001/result.json b/formal/sonification/mat009/audit/independent-replay-001/result.json new file mode 100644 index 0000000..9d8bad8 --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/result.json @@ -0,0 +1,128 @@ +{ + "allowed_logical_axioms": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--version" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "lean-version", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "build-00-SplitModel", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "build-01-DiagnosticFirstOwner", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "build-02-TypedConsumer", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "build-03-ExactTypes", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "build-04-LeanAudit", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "21d9dcb639ded4b2c3047045038ff0d3a3c216f2c1f57554d0832fb81e7042cc" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "IndependentAxioms.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "independent-axioms", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "18eddea3912a9320626a48d5eb5e2a91dec2c04c371fb9914479feabc8f1ee0d" + } + ], + "compiler_auxiliary_axioms": [ + "MAT009.initial._elambda_1", + "MAT009.step._elambda_1" + ], + "compiler_auxiliary_count": 146, + "cpython_refinement": "OPEN", + "declaration_count": 351, + "independently_queried_named_theorems": 22, + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "logical_violations": [], + "module_count": 5, + "proof_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "proof_sha256": { + "formal/sonification/mat009/lean/DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "formal/sonification/mat009/lean/ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "formal/sonification/mat009/lean/LeanAudit.lean": "7aeabffbd65357e4ea41d773950bc7b52c892c5347b259f51d6a3831296aced8", + "formal/sonification/mat009/lean/SplitModel.lean": "2d6f80e9749e846db5f7c54bcc189c1ae3f345e19677842c002c2bea69790795", + "formal/sonification/mat009/lean/TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa" + }, + "source_commit": "0758a96360726aafbb07abed34620eda178407ae", + "source_sha256": { + "materials/mat_spec_008.py": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", + "materials/mat_spec_009.py": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690" + }, + "status": "PASS", + "theorem_count_including_generated": 95 +} diff --git a/formal/sonification/mat009/audit/independent-replay-001/work/DiagnosticFirstOwner.lean b/formal/sonification/mat009/audit/independent-replay-001/work/DiagnosticFirstOwner.lean new file mode 100644 index 0000000..7283ce6 --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/work/DiagnosticFirstOwner.lean @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some first + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/audit/independent-replay-001/work/ExactTypes.lean b/formal/sonification/mat009/audit/independent-replay-001/work/ExactTypes.lean new file mode 100644 index 0000000..7e5be3e --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/work/ExactTypes.lean @@ -0,0 +1,98 @@ +import TypedConsumer + +/-! +Independent typed uses of the intended MAT009 model propositions. A theorem +with the same name but a weaker type, such as `True`, cannot satisfy these +consumers. These are statements about eligible-row mathematical models only. +-/ + +namespace MAT009.ExactTypes +open MAT009 + +example (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := + M009_R1_initial parent role campaign lab reason + +example (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := + M009_R2_assignment_overwrite s row + +example (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := + M009_R3_cross_role_trigger s row + +example (s : State) (row : Row) (role : Role) + (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := + M009_R4_stickiness s row role campaign lab reason + +example (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := + M009_R5_final_set_intersection s + +example (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := + M009_R5_parent_union s + +example (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := + M009_R6_arbitrary_finite_scan parent rows role campaign lab reason + +example (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign := + M009_R6_latest_owner parent rows campaign + +example (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := + M009_R6_final_leakage_iff parent rows + +example : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := + M009_R7_nonvacuous + +example (registry : MAT009.Diagnostic.Registry) + (updates : List (String × MAT009.Diagnostic.Owner)) + (key : String) (first : MAT009.Diagnostic.Owner) + (h : registry key = some first) : + (MAT009.Diagnostic.scan registry updates) key = some first := + MAT009.Diagnostic.scan_first_owner_sticky registry updates key first h + +end MAT009.ExactTypes diff --git a/formal/sonification/mat009/audit/independent-replay-001/work/IndependentAxioms.lean b/formal/sonification/mat009/audit/independent-replay-001/work/IndependentAxioms.lean new file mode 100644 index 0000000..83c7f77 --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/work/IndependentAxioms.lean @@ -0,0 +1,23 @@ +import ExactTypes +#print axioms MAT009.M009_R1_initial +#print axioms MAT009.M009_R2_assignment_overwrite +#print axioms MAT009.M009_R3_cross_role_trigger +#print axioms MAT009.M009_R4_stickiness +#print axioms MAT009.M009_R5_final_set_intersection +#print axioms MAT009.M009_R5_parent_union +#print axioms MAT009.M009_R6_cross_trigger_in_finite_scan +#print axioms MAT009.M009_R6_arbitrary_finite_scan +#print axioms MAT009.M009_R6_latest_owner +#print axioms MAT009.M009_R6_parent_reason_survives +#print axioms MAT009.M009_R6_final_leakage_iff +#print axioms MAT009.M009_R7_accepted_example +#print axioms MAT009.M009_R7_rejected_example +#print axioms MAT009.M009_R7_nonvacuous +#print axioms MAT009.Consumer.parent_reason_blocks_any_scan +#print axioms MAT009.Consumer.shared_campaign_blocks_any_scan +#print axioms MAT009.Diagnostic.register_first_owner +#print axioms MAT009.Diagnostic.register_new_owner +#print axioms MAT009.Diagnostic.register_other_identity +#print axioms MAT009.Diagnostic.register_preserves_existing +#print axioms MAT009.Diagnostic.scan_first_owner_sticky +#print axioms MAT009.Diagnostic.first_owner_not_last_writer diff --git a/formal/sonification/mat009/audit/independent-replay-001/work/LeanAudit.lean b/formal/sonification/mat009/audit/independent-replay-001/work/LeanAudit.lean new file mode 100644 index 0000000..897b509 --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/work/LeanAudit.lean @@ -0,0 +1,66 @@ +import ExactTypes +import Lean + +/-! +Enumerate every declaration whose origin is a MAT009 proof module, including +helpers and typed consumers. The script that runs this module checks the +inventory. `collectAxioms` traverses each declaration's logical dependencies. +-/ + +open Lean Elab Command + +run_cmd do + let env ← getEnv + let origins := #[ + `SplitModel, `DiagnosticFirstOwner, `TypedConsumer, `ExactTypes, + env.mainModule + ] + for mod in origins do + unless mod == env.mainModule || (env.getModuleIdx? mod).isSome do + throwError "missing required imported module {mod}" + logInfo m!"MAT009_MODULE {mod}" + for mod in env.header.moduleNames do + logInfo m!"MAT009_IMPORT {mod}" + let allowed := #[`propext, `Quot.sound, `Classical.choice] + let mut seen : Nat := 0 + let mut theorems : Nat := 0 + let declarations := env.checked.get.constants.toList.mergeSort fun a b => + decide (a.1.toString ≤ b.1.toString) + for (name, info) in declarations do + let origin := match env.getModuleIdxFor? name with + | some idx => env.header.moduleNames[idx.toNat]! + | none => env.mainModule + if origins.contains origin then + seen := seen + 1 + if info matches .thmInfo _ then + theorems := theorems + 1 + let generated := name.toString.endsWith "_cstage1" || + name.toString.endsWith "_cstage2" || + (name.toString.splitOn "._closed_").length > 1 || + (name.toString.splitOn "._elambda_").length > 1 + if info matches .axiomInfo _ then + unless generated do + throwError "project axiom declaration {name}" + let axioms ← collectAxioms name + let unsafeDef : Bool := match info with + | .defnInfo d => d.safety == DefinitionSafety.unsafe + | _ => false + for ax in axioms do + unless allowed.contains ax || generated do + throwError "unapproved transitive axiom {ax} in {name} (origin {origin})" + if unsafeDef && !generated then + throwError "unsafe project definition {name}" + let row := Json.mkObj [ + ("origin", toJson origin.toString), + ("declaration", toJson name.toString), + ("kind", toJson (if generated then "compiler_auxiliary" else + if info matches .thmInfo _ then "theorem" else "non_theorem")), + ("is_axiom", toJson (info matches .axiomInfo _)), + ("unsafe_definition", toJson unsafeDef), + ("type", toJson (← liftTermElabM do + pure (← Lean.Meta.ppExpr info.type).pretty)), + ("axioms", toJson (axioms.map Name.toString))] + logInfo m!"MAT009_DECL {row.compress}" + if seen == 0 || theorems == 0 then + throwError "empty proof inventory" + logInfo m!"MAT009_AUDIT declarations={seen} theorems={theorems}" diff --git a/formal/sonification/mat009/audit/independent-replay-001/work/SplitModel.lean b/formal/sonification/mat009/audit/independent-replay-001/work/SplitModel.lean new file mode 100644 index 0000000..dc3eaf6 --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/work/SplitModel.lean @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/independent-replay-001/work/TypedConsumer.lean b/formal/sonification/mat009/audit/independent-replay-001/work/TypedConsumer.lean new file mode 100644 index 0000000..2158aca --- /dev/null +++ b/formal/sonification/mat009/audit/independent-replay-001/work/TypedConsumer.lean @@ -0,0 +1,65 @@ +import SplitModel +import DiagnosticFirstOwner + +/-! +A separate import consumer for the MAT009 split model. These declarations +type-check the public R1–R7 interface and derive blocked outcomes from the +generic finite-scan and parent-reason theorems. +-/ + +namespace MAT009.Consumer + +#check M009_R1_initial +#check M009_R2_assignment_overwrite +#check M009_R3_cross_role_trigger +#check M009_R4_stickiness +#check M009_R5_final_set_intersection +#check M009_R5_parent_union +#check M009_R6_cross_trigger_in_finite_scan +#check M009_R6_arbitrary_finite_scan +#check M009_R6_latest_owner +#check M009_R6_parent_reason_survives +#check M009_R6_final_leakage_iff +#check M009_R7_accepted_example +#check M009_R7_rejected_example +#check M009_R7_nonvacuous +#check MAT009.Diagnostic.scan_first_owner_sticky + +theorem parent_reason_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (reason : String) (h : parent reason) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + exact ⟨reason, M009_R6_parent_reason_survives parent rows reason h⟩ + +theorem shared_campaign_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (campaign : String) + (htrain : ∃ row ∈ rows, + row.role = .train ∧ row.campaign = campaign) + (hholdout : ∃ row ∈ rows, + row.role = .holdout ∧ row.campaign = campaign) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + refine ⟨leakageReason, Or.inr ?_⟩ + exact (M009_R6_final_leakage_iff parent rows).2 + (Or.inl ⟨campaign, htrain, hholdout⟩) + +#print axioms M009_R1_initial +#print axioms M009_R2_assignment_overwrite +#print axioms M009_R3_cross_role_trigger +#print axioms M009_R4_stickiness +#print axioms M009_R5_final_set_intersection +#print axioms M009_R5_parent_union +#print axioms M009_R6_cross_trigger_in_finite_scan +#print axioms M009_R6_arbitrary_finite_scan +#print axioms M009_R6_latest_owner +#print axioms M009_R6_parent_reason_survives +#print axioms M009_R6_final_leakage_iff +#print axioms M009_R7_accepted_example +#print axioms M009_R7_rejected_example +#print axioms M009_R7_nonvacuous +#print axioms parent_reason_blocks_any_scan +#print axioms shared_campaign_blocks_any_scan +#print axioms MAT009.Diagnostic.scan_first_owner_sticky +#print axioms MAT009.Diagnostic.first_owner_not_last_writer + +end MAT009.Consumer diff --git a/formal/sonification/mat009/audit/independent_cpython.py b/formal/sonification/mat009/audit/independent_cpython.py new file mode 100644 index 0000000..126fad8 --- /dev/null +++ b/formal/sonification/mat009/audit/independent_cpython.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 +"""Small independent CPython observations for the frozen MAT009/MAT008 pair.""" + +from __future__ import annotations + +import hashlib +import importlib +import json +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[4] +sys.path.insert(0, str(ROOT)) + +mat_spec_009 = importlib.import_module("materials.mat_spec_009") + +OUT = Path(__file__).resolve().parent / "independent-cpython-001.json" +TARGET_SHA = "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690" +PARENT_SHA = "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08" + + +def fixture() -> list[dict]: + rows = [] + for index, (campaign, lab, role, source, diagnostic) in enumerate( + ( + ("CAMP_A", "LAB_A", "TRAIN", "a" * 64, "c" * 64), + ("CAMP_B", "LAB_B", "HOLDOUT", "b" * 64, "d" * 64), + ) + ): + for phase in ("HE_I", "HE_II"): + rows.append( + { + "row_id": f"ROW_{index}_{phase}", + "campaign_id": campaign, + "lab_family_id": lab, + "original_run_id": f"RUN_{index}", + "source_document_id": f"DOC_{index}", + "source_sha256": source, + "diagnostic_sha256": diagnostic, + "diagnostic_event_id": f"DIAG_{index}_{phase}", + "source_type": "ORIGINAL_EXPERIMENTAL_RECORD", + "measurement_quantity": "HEAT_CAPACITY", + "measurement_unit": "J_PER_MOL_K", + "measurement_value": "12.34", + "measurement_sigma": "0.01", + "diagnostic_sigma": "0.02", + "diagnostic_basis": "INDEPENDENT_NON_TEMPERATURE_DIAGNOSTIC", + "label_basis": "ORTHOGONAL_DIAGNOSTIC", + "phase": phase, + "receiver_scale": "5", + "pre_registration_sha256": "e" * 64, + "pressure_condition": "HE4_SVP", + "study_role": role, + } + ) + return rows + + +class HashString(str): + def __new__(cls, value: str, assigned_hash: int): + result = str.__new__(cls, value) + result.assigned_hash = assigned_hash + return result + + def __hash__(self) -> int: + return self.assigned_hash + + +class UnhashableString(str): + __hash__ = None + + +class ExplodingDict(dict): + def get(self, key, default=None): + raise RuntimeError("dict subclass get failed") + + +def no_physical_claim(result: dict) -> bool: + return ( + result["physical_evidence_admitted"] is False + and result["independence_authenticated"] is False + and result["heldout_accuracy"] is None + ) + + +def main() -> int: + observed_sha = { + name: hashlib.sha256((ROOT / "materials" / name).read_bytes()).hexdigest() + for name in ("mat_spec_009.py", "mat_spec_008.py") + } + assert observed_sha == {"mat_spec_009.py": TARGET_SHA, "mat_spec_008.py": PARENT_SHA} + + clean = mat_spec_009.check_future_challenge(fixture()) + assert clean["status"] == "STRUCTURAL_ONLY_UNAUTHENTICATED" and clean["reasons"] == [] + assert no_physical_claim(clean) + + invalid_role_rows = fixture() + invalid_role_rows[0].update( + { + "study_role": "UNDECLARED", + "measurement_unit": "BAD", + "receiver_scale": "BAD", + "diagnostic_sha256": None, + "pre_registration_sha256": "", + } + ) + invalid_role = mat_spec_009.check_future_challenge(invalid_role_rows) + assert invalid_role["reasons"] == [ + "TRAIN_REQUIRES_BOTH_PHASES", + "UNDECLARED_TRAIN_HOLDOUT_ROLE", + ] + assert no_physical_claim(invalid_role) + + parent_skip_rows = fixture() + parent_skip_rows[0]["original_run_id"] = "" + parent_skip = mat_spec_009.check_future_challenge(parent_skip_rows) + assert parent_skip["reasons"] == [ + "BOTH_PHASES_REQUIRED_FOR_EACH_CAMPAIGN", + "MISSING_OR_INVALID_SOURCE_IDENTITIES", + ] + assert parent_skip["train_campaigns"] == 1 and no_physical_claim(parent_skip) + + first = HashString("SAME_CAMP", 11) + second = HashString("SAME_CAMP", 23) + assert first == second and hash(first) != hash(second) + subclass_rows = fixture() + for row in subclass_rows[:2]: + row["campaign_id"] = first + for row in subclass_rows[2:]: + row["campaign_id"] = second + subclass_result = mat_spec_009.check_future_challenge(subclass_rows) + assert subclass_result["reasons"] == [] and no_physical_claim(subclass_result) + for row in subclass_rows: + row["campaign_id"] = "SAME_CAMP" + builtin_result = mat_spec_009.check_future_challenge(subclass_rows) + assert {"CAMPAIGN_CROSSES_TRAIN_HOLDOUT", "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS"} <= set( + builtin_result["reasons"] + ) + assert no_physical_claim(builtin_result) + + exploding_rows = fixture() + exploding_rows[0] = ExplodingDict(exploding_rows[0]) + try: + mat_spec_009.check_future_challenge(exploding_rows) + except RuntimeError as error: + assert str(error) == "dict subclass get failed" + exploding = type(error).__name__ + else: + raise AssertionError("dict subclass did not raise") + unhashable_rows = fixture() + unhashable_rows[0]["row_id"] = UnhashableString("ROW_0_HE_I") + try: + mat_spec_009.check_future_challenge(unhashable_rows) + except TypeError as error: + unhashable = type(error).__name__ + else: + raise AssertionError("unhashable row identity did not raise") + + marked_rows = fixture() + for row in marked_rows: + row["synthetic_fixture"] = True + marked = mat_spec_009.check_future_challenge(marked_rows) + assert marked["reasons"] == ["SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT"] + for row in marked_rows: + row["synthetic_fixture"] = 1 + integer_marker = mat_spec_009.check_future_challenge(marked_rows) + assert integer_marker["reasons"] == [] and no_physical_claim(integer_marker) + + controls = mat_spec_009.negative_controls() + assert len(controls) == 14 and all( + row["result"] == "PASS_REJECTED" and row["physical_evidence_admitted"] == "false" + for row in controls + ) + report = { + "status": "PASS_FOR_LISTED_CASES_ONLY", + "source_sha256": observed_sha, + "clean_status": clean["status"], + "clean_reasons": clean["reasons"], + "invalid_role_reasons": invalid_role["reasons"], + "parent_skip_reasons": parent_skip["reasons"], + "subclass_equal_text_unequal_hash_reasons": subclass_result["reasons"], + "builtin_same_text_reason_count": len(builtin_result["reasons"]), + "dict_subclass_exception": exploding, + "unhashable_string_exception": unhashable, + "synthetic_true_reasons": marked["reasons"], + "synthetic_integer_one_reasons": integer_marker["reasons"], + "synthetic_control_count": len(controls), + "physical_evidence_admitted": False, + "cpython_refinement": "OPEN", + } + OUT.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + print(json.dumps(report, sort_keys=True)) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/formal/sonification/mat009/audit/independent_cpython.stderr b/formal/sonification/mat009/audit/independent_cpython.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent_cpython.stdout b/formal/sonification/mat009/audit/independent_cpython.stdout new file mode 100644 index 0000000..1616008 --- /dev/null +++ b/formal/sonification/mat009/audit/independent_cpython.stdout @@ -0,0 +1 @@ +{"builtin_same_text_reason_count": 7, "clean_reasons": [], "clean_status": "STRUCTURAL_ONLY_UNAUTHENTICATED", "cpython_refinement": "OPEN", "dict_subclass_exception": "RuntimeError", "invalid_role_reasons": ["TRAIN_REQUIRES_BOTH_PHASES", "UNDECLARED_TRAIN_HOLDOUT_ROLE"], "parent_skip_reasons": ["BOTH_PHASES_REQUIRED_FOR_EACH_CAMPAIGN", "MISSING_OR_INVALID_SOURCE_IDENTITIES"], "physical_evidence_admitted": false, "source_sha256": {"mat_spec_008.py": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", "mat_spec_009.py": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690"}, "status": "PASS_FOR_LISTED_CASES_ONLY", "subclass_equal_text_unequal_hash_reasons": [], "synthetic_control_count": 14, "synthetic_integer_one_reasons": [], "synthetic_true_reasons": ["SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT"], "unhashable_string_exception": "TypeError"} diff --git a/formal/sonification/mat009/audit/independent_replay.py b/formal/sonification/mat009/audit/independent_replay.py new file mode 100644 index 0000000..837cce2 --- /dev/null +++ b/formal/sonification/mat009/audit/independent_replay.py @@ -0,0 +1,198 @@ +#!/usr/bin/env python3 +"""Independent MAT009 audit runner; all generated files stay under audit/.""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[4] +AUDIT = Path(__file__).resolve().parent +PROOF = ROOT / "formal/sonification/mat009/lean" +OUT = AUDIT / "independent-replay-001" +LEAN = Path("/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean") +PROOF_COMMIT = "a09aab6572fb9c3875d5f2940bdb17ec55c358d5" +SOURCE_COMMIT = "0758a96360726aafbb07abed34620eda178407ae" +MODULES = ("SplitModel", "DiagnosticFirstOwner", "TypedConsumer", "ExactTypes", "LeanAudit") +ALLOWED = {"propext", "Quot.sound", "Classical.choice"} + + +def sha(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def git_show(commit: str, relative: str) -> bytes: + return subprocess.check_output(["git", "show", f"{commit}:{relative}"], cwd=ROOT) + + +def run(label: str, argv: list[str], cwd: Path, env: dict[str, str]) -> dict: + result = subprocess.run(argv, cwd=cwd, env=env, capture_output=True, timeout=180) + (OUT / f"{label}.stdout").write_bytes(result.stdout) + (OUT / f"{label}.stderr").write_bytes(result.stderr) + return { + "label": label, + "argv": argv, + "cwd": str(cwd), + "exit_code": result.returncode, + "stdout_sha256": sha(result.stdout), + "stderr_sha256": sha(result.stderr), + } + + +def main() -> int: + OUT.mkdir(exist_ok=False) + work = OUT / "work" + work.mkdir() + source_inputs = {} + for relative, commit in ( + ("materials/mat_spec_009.py", SOURCE_COMMIT), + ("materials/mat_spec_008.py", SOURCE_COMMIT), + ): + raw = (ROOT / relative).read_bytes() + if raw != git_show(commit, relative): + raise AssertionError(f"frozen source drift: {relative}") + source_inputs[relative] = sha(raw) + proof_inputs = {} + for module in MODULES: + relative = f"formal/sonification/mat009/lean/{module}.lean" + raw = (ROOT / relative).read_bytes() + if raw != git_show(PROOF_COMMIT, relative): + raise AssertionError(f"proof input drift: {relative}") + (work / f"{module}.lean").write_bytes(raw) + proof_inputs[relative] = sha(raw) + env = {**os.environ, "LEAN_PATH": str(work), "TMPDIR": str(work)} + commands = [run("lean-version", [str(LEAN), "--version"], work, env)] + for number, module in enumerate(MODULES): + commands.append( + run( + f"build-{number:02d}-{module}", + [ + str(LEAN), + "--error=warning", + "-o", + str(work / f"{module}.olean"), + f"{module}.lean", + ], + work, + env, + ) + ) + if any(command["exit_code"] != 0 for command in commands): + raise AssertionError("fresh Lean build failed") + + lines = (OUT / "build-04-LeanAudit.stdout").read_text().splitlines() + modules = { + line.removeprefix("MAT009_MODULE ") for line in lines if line.startswith("MAT009_MODULE ") + } + declarations = [ + json.loads(line.removeprefix("MAT009_DECL ")) + for line in lines + if line.startswith("MAT009_DECL ") + ] + if modules != set(MODULES) or len(declarations) != 351: + raise AssertionError("fresh module or declaration inventory differs") + if len({row["declaration"] for row in declarations}) != len(declarations): + raise AssertionError("duplicate declaration") + logical_violations = [ + row["declaration"] + for row in declarations + if row["kind"] != "compiler_auxiliary" + and (row["is_axiom"] or row["unsafe_definition"] or set(row["axioms"]) - ALLOWED) + ] + if logical_violations: + raise AssertionError(f"logical violations: {logical_violations}") + + named_theorems = ( + "MAT009.M009_R1_initial", + "MAT009.M009_R2_assignment_overwrite", + "MAT009.M009_R3_cross_role_trigger", + "MAT009.M009_R4_stickiness", + "MAT009.M009_R5_final_set_intersection", + "MAT009.M009_R5_parent_union", + "MAT009.M009_R6_cross_trigger_in_finite_scan", + "MAT009.M009_R6_arbitrary_finite_scan", + "MAT009.M009_R6_latest_owner", + "MAT009.M009_R6_parent_reason_survives", + "MAT009.M009_R6_final_leakage_iff", + "MAT009.M009_R7_accepted_example", + "MAT009.M009_R7_rejected_example", + "MAT009.M009_R7_nonvacuous", + "MAT009.Consumer.parent_reason_blocks_any_scan", + "MAT009.Consumer.shared_campaign_blocks_any_scan", + "MAT009.Diagnostic.register_first_owner", + "MAT009.Diagnostic.register_new_owner", + "MAT009.Diagnostic.register_other_identity", + "MAT009.Diagnostic.register_preserves_existing", + "MAT009.Diagnostic.scan_first_owner_sticky", + "MAT009.Diagnostic.first_owner_not_last_writer", + ) + (work / "IndependentAxioms.lean").write_text( + "import ExactTypes\n" + "\n".join(f"#print axioms {name}" for name in named_theorems) + "\n" + ) + commands.append( + run( + "independent-axioms", + [str(LEAN), "--error=warning", "IndependentAxioms.lean"], + work, + env, + ) + ) + if commands[-1]["exit_code"] != 0: + raise AssertionError("independent theorem axiom query failed") + text = (OUT / "independent-axioms.stdout").read_text() + printed = {} + pattern = re.compile( + r"^'([^']+)' (?:depends on axioms: \[([^]]*)\]|does not depend on any axioms)$" + ) + for line in text.splitlines(): + match = pattern.match(line) + if match: + printed[match[1]] = sorted( + set(map(str.strip, match[2].split(","))) if match[2] else set() + ) + if set(printed) != set(named_theorems) or any(set(xs) - ALLOWED for xs in printed.values()): + raise AssertionError("independent theorem axiom result differs") + (OUT / "independent-axioms.json").write_text( + json.dumps(printed, indent=2, sort_keys=True) + "\n" + ) + + auxiliary_axioms = [ + row for row in declarations if row["kind"] == "compiler_auxiliary" and row["is_axiom"] + ] + report = { + "status": "PASS", + "source_commit": SOURCE_COMMIT, + "proof_commit": PROOF_COMMIT, + "source_sha256": source_inputs, + "proof_sha256": proof_inputs, + "lean_executable_sha256": sha(LEAN.read_bytes()), + "commands": commands, + "module_count": len(modules), + "declaration_count": len(declarations), + "theorem_count_including_generated": sum(row["kind"] == "theorem" for row in declarations), + "compiler_auxiliary_count": sum( + row["kind"] == "compiler_auxiliary" for row in declarations + ), + "compiler_auxiliary_axioms": [row["declaration"] for row in auxiliary_axioms], + "logical_violations": logical_violations, + "independently_queried_named_theorems": len(printed), + "allowed_logical_axioms": sorted(ALLOWED), + "cpython_refinement": "OPEN", + } + (OUT / "result.json").write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + print( + json.dumps( + {"status": "PASS", "declarations": len(declarations), "named_theorems": len(printed)}, + sort_keys=True, + ) + ) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/formal/sonification/mat009/audit/independent_replay.stderr b/formal/sonification/mat009/audit/independent_replay.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/independent_replay.stdout b/formal/sonification/mat009/audit/independent_replay.stdout new file mode 100644 index 0000000..ded0d57 --- /dev/null +++ b/formal/sonification/mat009/audit/independent_replay.stdout @@ -0,0 +1 @@ +{"declarations": 351, "named_theorems": 22, "status": "PASS"} diff --git a/formal/sonification/mat009/audit/make_report.py b/formal/sonification/mat009/audit/make_report.py new file mode 100644 index 0000000..33298ef --- /dev/null +++ b/formal/sonification/mat009/audit/make_report.py @@ -0,0 +1,357 @@ +#!/usr/bin/env python3 +"""Assemble the independent MAT009 checkpoint audit from retained raw logs.""" + +from __future__ import annotations + +import hashlib +import json +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[4] +AUDIT = Path(__file__).resolve().parent +OUT = AUDIT / "report.json" +LEAN = "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean" +PROOF_COMMIT = "a09aab6572fb9c3875d5f2940bdb17ec55c358d5" +SOURCE_COMMIT = "0758a96360726aafbb07abed34620eda178407ae" + + +def sha(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def obj(relative: str) -> dict: + return json.loads((AUDIT / relative).read_text()) + + +def local_log(label: str, argv: list[str], exit_code: int, *, env: dict | None = None) -> dict: + stdout = AUDIT / f"{label}.stdout" + stderr = AUDIT / f"{label}.stderr" + assert stdout.is_file() and stderr.is_file() + return { + "label": label, + "argv": argv, + "cwd": str(ROOT), + "env_overrides": env or {}, + "exit_code": exit_code, + "stdout": str(stdout.relative_to(ROOT)), + "stderr": str(stderr.relative_to(ROOT)), + "stdout_sha256": sha(stdout), + "stderr_sha256": sha(stderr), + } + + +def main() -> int: + fresh = obj("independent-replay-001/result.json") + checker = obj("checker-replay-001/result.json") + negatives = obj("negative-probe-001/result.json") + verification = obj("verification-probe-002/result.json") + archived = obj("archive-integrity-001.json") + finite = obj("independent-cpython-001.json") + full_path = ROOT / "formal/sonification/evidence/mat009-full-pytest-001/receipt.json" + full = json.loads(full_path.read_text()) + assert all(x["status"] == "PASS" for x in (fresh, checker, negatives, verification, archived)) + assert finite["status"] == "PASS_FOR_LISTED_CASES_ONLY" + assert full["exit_code"] == 0 + + negative_details = {} + for row in negatives["results"]: + name = row["mutation"] + detail = obj(f"negative-probe-001/{name}/result.json") + negative_details[name] = { + "mutant_sha256": row["mutant_sha256"], + "last_job": row["observed_last_job"], + "exit_code": row["observed_exit_code"], + "expected_observation": row["expected_observation"], + "jobs": detail["commands"], + "raw_log_directory": f"formal/sonification/mat009/audit/negative-probe-001/{name}", + } + disguised = obj("negative-probe-001/auxiliary_named_false_axiom/result.json") + count_gate_error = (AUDIT / "count_gate.stderr").read_text() + assert "complete declaration/theorem inventory changed" in count_gate_error + + nominal_commands = [ + local_log( + "nominal-source-binding", + ["python3", "-B", "formal/sonification/mat009/source/source_bind.py"], + 0, + env={"PYTHONDONTWRITEBYTECODE": "1"}, + ), + local_log( + "nominal-source-receipts", + ["python3", "-B", "formal/sonification/mat009/verify_evidence.py"], + 0, + env={"PYTHONDONTWRITEBYTECODE": "1"}, + ), + local_log( + "nominal-lean-receipt", + ["python3", "-B", "formal/sonification/mat009/lean/verify.py"], + 0, + env={"PYTHONDONTWRITEBYTECODE": "1"}, + ), + local_log( + "nominal-negative-receipt", + ["python3", "-B", "formal/sonification/mat009/lean/verify_negative.py"], + 0, + env={"PYTHONDONTWRITEBYTECODE": "1"}, + ), + local_log( + "nominal-finite", + [ + "python3", + "-B", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_sonification_formal_mat009_split.py", + "-q", + ], + 0, + env={"PYTHONDONTWRITEBYTECODE": "1"}, + ), + ] + own_commands = [ + local_log( + "checker-replay-001", + [ + "python3", + "-B", + "formal/sonification/mat009/lean/check.py", + "--lean", + LEAN, + "--baseline-commit", + PROOF_COMMIT, + "--out", + "formal/sonification/mat009/audit/checker-replay-001", + ], + 0, + env={"PYTHONDONTWRITEBYTECODE": "1", "TMPDIR": str(AUDIT)}, + ), + local_log( + "independent_replay", + ["python3", "-B", "formal/sonification/mat009/audit/independent_replay.py"], + 0, + env={"PYTHONDONTWRITEBYTECODE": "1"}, + ), + local_log( + "negative_probe", + ["python3", "-B", "formal/sonification/mat009/audit/negative_probe.py"], + 0, + env={"PYTHONDONTWRITEBYTECODE": "1"}, + ), + local_log( + "verification_probe_002", + ["python3", "-B", "formal/sonification/mat009/audit/verification_probe.py"], + 0, + env={"PYTHONDONTWRITEBYTECODE": "1"}, + ), + local_log( + "independent_cpython", + ["python3", "-B", "formal/sonification/mat009/audit/independent_cpython.py"], + 0, + env={"PYTHONDONTWRITEBYTECODE": "1"}, + ), + local_log( + "archive_integrity", + ["python3", "-B", "formal/sonification/mat009/audit/archive_integrity.py"], + 0, + env={"PYTHONDONTWRITEBYTECODE": "1"}, + ), + local_log( + "count_gate", + ["python3", "-B", "formal/sonification/mat009/audit/count_gate_driver.py"], + 1, + env={"PYTHONDONTWRITEBYTECODE": "1"}, + ), + ] + report = { + "schema": "sonification-mat009-independent-audit-v1", + "target": "MAT-009-VERIFY-001", + "candidate_commit": "94a357284408e6bc24cfb9b2d49e9d4144791042", + "observed_head_after_additional_full_pytest_receipt": subprocess.check_output( + ["git", "rev-parse", "HEAD"], cwd=ROOT, text=True + ).strip(), + "source_identity": { + "tag": "mat-spec-009-v0.1.0", + "tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", + "commit": SOURCE_COMMIT, + "tree": "a6a03e1227e666680d656b886201ee9dde9de32d", + "mat009_blob": "c447f0ce76b91acf458221390ac4261166145a0b", + "mat009_sha256": fresh["source_sha256"]["materials/mat_spec_009.py"], + "direct_mat008_blob": "3117adbc3739c834f8203d5d2dd2b80d6caf862b", + "direct_mat008_sha256": fresh["source_sha256"]["materials/mat_spec_008.py"], + }, + "proof_identity": { + "proof_input_commit": PROOF_COMMIT, + "module_sha256": fresh["proof_sha256"], + "all_proof_input_sha256": checker["input_sha256"], + "lean_executable_sha256": fresh["lean_executable_sha256"], + "toolchain_imports_verified": archived["toolchain_import_count"], + }, + "verdicts": { + "exact_model": "PASS", + "finite": "PASS", + "source_binding": "PASS", + "cpython_refinement": "OPEN", + "audit": "FAIL", + }, + "model_scope": { + "eligible_rows_only": True, + "arbitrary_parent_reason_set": True, + "arbitrary_finite_eligible_row_list": True, + "exact_typed_consumer_compiled": True, + "named_theorems_independently_queried": fresh["independently_queried_named_theorems"], + "logical_violations_in_nominal_declarations": fresh["logical_violations"], + "declarations": fresh["declaration_count"], + "theorems_including_generated": fresh["theorem_count_including_generated"], + "compiler_auxiliaries": fresh["compiler_auxiliary_count"], + "compiler_generated_axioms_in_nominal_inventory": fresh["compiler_auxiliary_axioms"], + "nonvacuity": "R7 supplies both structural and blocked model witnesses", + "false_or_weakened_named_theorem_found": False, + }, + "finite_scope": { + "focused_unittest_methods": 18, + "four_row_role_campaign_lab_assignments": 4096, + "independent_counterexamples": finite, + "archived_negative_cases_verified": len(archived["negative_cases"]), + "frozen_synthetic_controls": finite["synthetic_control_count"], + "full_pytest_receipt": { + "argv": full["argv"], + "cwd": full["cwd"], + "checkout_commit": full["checkout_commit"], + "exit_code": full["exit_code"], + "stdout_sha256": full["stdout_sha256"], + "stderr_sha256": full["stderr_sha256"], + "summary": archived["full_pytest_reported"], + "explicit_input_count": len(full["inputs"]), + }, + }, + "retained_evidence": { + "nominal_manifest_sha256": archived["nominal_manifest_sha256"], + "nominal_files_verified": archived["nominal_file_count"], + "nominal_audit_stdout_matches_fresh_replay": True, + "negative_manifest_sha256": archived["negative_manifest_sha256"], + "negative_files_verified": archived["negative_file_count"], + "failed_development_attempts_retained": archived[ + "failed_development_attempts_retained" + ], + "source_receipts_verified": archived["source_receipts"], + "receipt_deletion_controls_detected": sum( + x["expected_rejection"] + for x in verification["results"] + if x["label"].startswith("missing-") + ), + "receipt_verifier_fail_open_found": False, + }, + "scientific_boundary": { + "physical_evidence_admitted": False, + "independence_authenticated": False, + "heldout_accuracy": None, + "classifier_accuracy_proved": False, + "empirical_validation": "OPEN", + "receipt_digests_are_syntactic_assertions_only": True, + }, + "finding": { + "id": "MAT009-AUDIT-001", + "status": "CONFIRMED", + "component": "formal/sonification/mat009/lean/LeanAudit.lean:37", + "description": ( + "The audit labels declarations as compiler auxiliaries from " + "user-controllable name suffixes and exempts that class from " + "project-axiom and transitive-axiom checks." + ), + "minimal_mutation": [ + "axiom auditor_false_cstage1 : False", + "theorem auditor_false_proof_cstage1 : False := auditor_false_cstage1", + ], + "mutant_splitmodel_sha256": negative_details["auxiliary_named_false_axiom"][ + "mutant_sha256" + ], + "lean_audit_exit_code": negative_details["auxiliary_named_false_axiom"]["exit_code"], + "audit_summary": disguised["audit_summary"], + "logged_false_declarations": disguised["disguised_declarations"], + "ordinary_axiom_control_exit_code": negative_details["ordinary_false_axiom"][ + "exit_code" + ], + "integrated_checker_mutation_exit_code": next( + x["exit_code"] + for x in verification["results"] + if x["label"] == "mutated-proof-checker" + ), + "integrated_checker_error": obj("verification-probe-002/checker-result/result.json")[ + "error" + ], + "fixed_count_gate_mutation_exit_code": 1, + "fixed_count_gate_error": "complete declaration/theorem inventory changed", + "current_named_theorem_axiom_impact": "NONE_OBSERVED", + "boundary": ( + "Current proof-source commit and fixed declaration counts reject " + "this changed input; " + "the standalone Lean audit gate is unsafe for future rebaselines." + ), + }, + "executions": { + "nominal_verifiers_and_finite": nominal_commands, + "own_top_level": own_commands, + "fresh_lean_jobs": fresh["commands"], + "isolated_lean_mutation_jobs": negative_details, + "source_and_receipt_negative_jobs": verification["results"], + "raw_logs_root": "formal/sonification/mat009/audit", + }, + "failed_audit_harness_attempt": { + "exit_code": 1, + "cause": ( + "Audit drivers initially lacked the repository import path; " + "three receipt deletions still rejected." + ), + "raw_log": "formal/sonification/mat009/audit/verification_probe.stdout", + "detail": "formal/sonification/mat009/audit/verification-probe-001/result.json", + "accepted_negative_replay": "verification-probe-002", + }, + "limitations": [ + "No theorem establishes source-to-model or CPython refinement for MAT009 and MAT008.", + ( + "R7's two-row structural witness is a model witness only; MAT009 " + "requires both phases in each source split." + ), + ( + "The Lean row model omits child skip guards, parent implementation, " + "phases, receipts, diagnostics, and other child reasons." + ), + ( + "Finite tests and archived execution receipts cover listed cases only; " + "the full pytest receipt lists no explicit inputs." + ), + ( + "Python subclass equality, hashing, dict methods, and exceptions " + "escape the exact built-in refinement domain." + ), + ( + "All candidate identities and digests are self-declared. No physical " + "independence, prospective registration, or accuracy is authenticated." + ), + ], + "auditor_file_scope": "formal/sonification/mat009/audit/**", + "production_files_modified_by_auditor": False, + "auditor_committed_or_pushed": False, + } + OUT.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + print( + json.dumps( + { + "audit": report["verdicts"]["audit"], + "finding": report["finding"]["id"], + "report": str(OUT), + }, + sort_keys=True, + ) + ) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/formal/sonification/mat009/audit/make_report.stderr b/formal/sonification/mat009/audit/make_report.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/make_report.stdout b/formal/sonification/mat009/audit/make_report.stdout new file mode 100644 index 0000000..e486a70 --- /dev/null +++ b/formal/sonification/mat009/audit/make_report.stdout @@ -0,0 +1 @@ +{"audit": "FAIL", "finding": "MAT009-AUDIT-001", "report": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/report.json"} diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-04-LeanAudit.stdout new file mode 100644 index 0000000..20a4ecc --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/build-04-LeanAudit.stdout @@ -0,0 +1,1666 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"False","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.auditor_false_cstage1","axioms":["MAT009.auditor_false_cstage1"]} +MAT009_DECL {"unsafe_definition":false,"type":"False","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.auditor_false_proof_cstage1","axioms":["MAT009.auditor_false_cstage1"]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.initial","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._closed_1._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.initial._elambda_1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.initial.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_3","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_4","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRow","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._closed_1._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.lastRole [] x = none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_2._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.leakageReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.leakageReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.noParent","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.noParent x = False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.noParent.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout ∧\n s.campaigns MAT009.Role.train \"SAME\" ∧ s.campaigns MAT009.Role.holdout \"SAME\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.overwrite_retains_both_split_memberships","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason ∧ ¬(MAT009.finalize s).childReason MAT009.leakageReason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_can_supply_leakage_reason","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (reason : String), s.parent reason → (MAT009.finalize s).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_reason_survives_finalization","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.scan s [] = s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_append","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key ↔\n s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), s.crossed → (MAT009.scan s rows).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_crossed_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.scan s rows)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_familyLeakage_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key ↔ s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_owner_last","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason ↔ s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.Role → String → Prop) → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.splitIntersection","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (members : MAT009.Role → String → Prop),\n MAT009.splitIntersection members = ∃ key, members MAT009.Role.train key ∧ members MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.splitIntersection.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.step","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.step._elambda_1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key ∨ role = row.role ∧ key = row.campaign,\n labs := fun role key => s.labs role key ∨ role = row.role ∧ key = row.lab,\n crossed := s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role,\n parent := s.parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.step.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String × MAT009.Diagnostic.Owner)) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (x : String) (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_15._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_16._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_17._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_18._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_19._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_20._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_21._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_AUDIT declarations=353 theorems=96 diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/mutant-source.lean.txt b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/mutant-source.lean.txt new file mode 100644 index 0000000..de82e6b --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/mutant-source.lean.txt @@ -0,0 +1,382 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom auditor_false_cstage1 : False +theorem auditor_false_proof_cstage1 : False := auditor_false_cstage1 + +end MAT009 diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/result.json b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/result.json new file mode 100644 index 0000000..ad2746b --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/result.json @@ -0,0 +1,106 @@ +{ + "audit_summary": [ + "MAT009_AUDIT declarations=353 theorems=96" + ], + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "exit_code": 0, + "label": "build-00-SplitModel", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "exit_code": 0, + "label": "build-01-DiagnosticFirstOwner", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "exit_code": 0, + "label": "build-02-TypedConsumer", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "exit_code": 0, + "label": "build-03-ExactTypes", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "exit_code": 0, + "label": "build-04-LeanAudit", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "1383254714bf4ce3d9cf3d50c98f8af57f86e59b1b0caf36a09ad6192b8a9167" + } + ], + "disguised_declarations": [ + { + "axioms": [ + "MAT009.auditor_false_cstage1" + ], + "declaration": "MAT009.auditor_false_cstage1", + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "False", + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.auditor_false_cstage1" + ], + "declaration": "MAT009.auditor_false_proof_cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "False", + "unsafe_definition": false + } + ], + "expected_observation": true, + "mutant_sha256": "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71", + "mutation": "auxiliary_named_false_axiom", + "observed_exit_code": 0, + "observed_last_job": "build-04-LeanAudit" +} diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/DiagnosticFirstOwner.lean b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/DiagnosticFirstOwner.lean new file mode 100644 index 0000000..7283ce6 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/DiagnosticFirstOwner.lean @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some first + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/ExactTypes.lean b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/ExactTypes.lean new file mode 100644 index 0000000..7e5be3e --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/ExactTypes.lean @@ -0,0 +1,98 @@ +import TypedConsumer + +/-! +Independent typed uses of the intended MAT009 model propositions. A theorem +with the same name but a weaker type, such as `True`, cannot satisfy these +consumers. These are statements about eligible-row mathematical models only. +-/ + +namespace MAT009.ExactTypes +open MAT009 + +example (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := + M009_R1_initial parent role campaign lab reason + +example (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := + M009_R2_assignment_overwrite s row + +example (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := + M009_R3_cross_role_trigger s row + +example (s : State) (row : Row) (role : Role) + (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := + M009_R4_stickiness s row role campaign lab reason + +example (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := + M009_R5_final_set_intersection s + +example (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := + M009_R5_parent_union s + +example (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := + M009_R6_arbitrary_finite_scan parent rows role campaign lab reason + +example (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign := + M009_R6_latest_owner parent rows campaign + +example (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := + M009_R6_final_leakage_iff parent rows + +example : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := + M009_R7_nonvacuous + +example (registry : MAT009.Diagnostic.Registry) + (updates : List (String × MAT009.Diagnostic.Owner)) + (key : String) (first : MAT009.Diagnostic.Owner) + (h : registry key = some first) : + (MAT009.Diagnostic.scan registry updates) key = some first := + MAT009.Diagnostic.scan_first_owner_sticky registry updates key first h + +end MAT009.ExactTypes diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/LeanAudit.lean b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/LeanAudit.lean new file mode 100644 index 0000000..897b509 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/LeanAudit.lean @@ -0,0 +1,66 @@ +import ExactTypes +import Lean + +/-! +Enumerate every declaration whose origin is a MAT009 proof module, including +helpers and typed consumers. The script that runs this module checks the +inventory. `collectAxioms` traverses each declaration's logical dependencies. +-/ + +open Lean Elab Command + +run_cmd do + let env ← getEnv + let origins := #[ + `SplitModel, `DiagnosticFirstOwner, `TypedConsumer, `ExactTypes, + env.mainModule + ] + for mod in origins do + unless mod == env.mainModule || (env.getModuleIdx? mod).isSome do + throwError "missing required imported module {mod}" + logInfo m!"MAT009_MODULE {mod}" + for mod in env.header.moduleNames do + logInfo m!"MAT009_IMPORT {mod}" + let allowed := #[`propext, `Quot.sound, `Classical.choice] + let mut seen : Nat := 0 + let mut theorems : Nat := 0 + let declarations := env.checked.get.constants.toList.mergeSort fun a b => + decide (a.1.toString ≤ b.1.toString) + for (name, info) in declarations do + let origin := match env.getModuleIdxFor? name with + | some idx => env.header.moduleNames[idx.toNat]! + | none => env.mainModule + if origins.contains origin then + seen := seen + 1 + if info matches .thmInfo _ then + theorems := theorems + 1 + let generated := name.toString.endsWith "_cstage1" || + name.toString.endsWith "_cstage2" || + (name.toString.splitOn "._closed_").length > 1 || + (name.toString.splitOn "._elambda_").length > 1 + if info matches .axiomInfo _ then + unless generated do + throwError "project axiom declaration {name}" + let axioms ← collectAxioms name + let unsafeDef : Bool := match info with + | .defnInfo d => d.safety == DefinitionSafety.unsafe + | _ => false + for ax in axioms do + unless allowed.contains ax || generated do + throwError "unapproved transitive axiom {ax} in {name} (origin {origin})" + if unsafeDef && !generated then + throwError "unsafe project definition {name}" + let row := Json.mkObj [ + ("origin", toJson origin.toString), + ("declaration", toJson name.toString), + ("kind", toJson (if generated then "compiler_auxiliary" else + if info matches .thmInfo _ then "theorem" else "non_theorem")), + ("is_axiom", toJson (info matches .axiomInfo _)), + ("unsafe_definition", toJson unsafeDef), + ("type", toJson (← liftTermElabM do + pure (← Lean.Meta.ppExpr info.type).pretty)), + ("axioms", toJson (axioms.map Name.toString))] + logInfo m!"MAT009_DECL {row.compress}" + if seen == 0 || theorems == 0 then + throwError "empty proof inventory" + logInfo m!"MAT009_AUDIT declarations={seen} theorems={theorems}" diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/SplitModel.lean b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/SplitModel.lean new file mode 100644 index 0000000..de82e6b --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/SplitModel.lean @@ -0,0 +1,382 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom auditor_false_cstage1 : False +theorem auditor_false_proof_cstage1 : False := auditor_false_cstage1 + +end MAT009 diff --git a/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/TypedConsumer.lean b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/TypedConsumer.lean new file mode 100644 index 0000000..2158aca --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/TypedConsumer.lean @@ -0,0 +1,65 @@ +import SplitModel +import DiagnosticFirstOwner + +/-! +A separate import consumer for the MAT009 split model. These declarations +type-check the public R1–R7 interface and derive blocked outcomes from the +generic finite-scan and parent-reason theorems. +-/ + +namespace MAT009.Consumer + +#check M009_R1_initial +#check M009_R2_assignment_overwrite +#check M009_R3_cross_role_trigger +#check M009_R4_stickiness +#check M009_R5_final_set_intersection +#check M009_R5_parent_union +#check M009_R6_cross_trigger_in_finite_scan +#check M009_R6_arbitrary_finite_scan +#check M009_R6_latest_owner +#check M009_R6_parent_reason_survives +#check M009_R6_final_leakage_iff +#check M009_R7_accepted_example +#check M009_R7_rejected_example +#check M009_R7_nonvacuous +#check MAT009.Diagnostic.scan_first_owner_sticky + +theorem parent_reason_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (reason : String) (h : parent reason) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + exact ⟨reason, M009_R6_parent_reason_survives parent rows reason h⟩ + +theorem shared_campaign_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (campaign : String) + (htrain : ∃ row ∈ rows, + row.role = .train ∧ row.campaign = campaign) + (hholdout : ∃ row ∈ rows, + row.role = .holdout ∧ row.campaign = campaign) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + refine ⟨leakageReason, Or.inr ?_⟩ + exact (M009_R6_final_leakage_iff parent rows).2 + (Or.inl ⟨campaign, htrain, hholdout⟩) + +#print axioms M009_R1_initial +#print axioms M009_R2_assignment_overwrite +#print axioms M009_R3_cross_role_trigger +#print axioms M009_R4_stickiness +#print axioms M009_R5_final_set_intersection +#print axioms M009_R5_parent_union +#print axioms M009_R6_cross_trigger_in_finite_scan +#print axioms M009_R6_arbitrary_finite_scan +#print axioms M009_R6_latest_owner +#print axioms M009_R6_parent_reason_survives +#print axioms M009_R6_final_leakage_iff +#print axioms M009_R7_accepted_example +#print axioms M009_R7_rejected_example +#print axioms M009_R7_nonvacuous +#print axioms parent_reason_blocks_any_scan +#print axioms shared_campaign_blocks_any_scan +#print axioms MAT009.Diagnostic.scan_first_owner_sticky +#print axioms MAT009.Diagnostic.first_owner_not_last_writer + +end MAT009.Consumer diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-04-LeanAudit.stdout new file mode 100644 index 0000000..b930fce --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/build-04-LeanAudit.stdout @@ -0,0 +1,1467 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +LeanAudit.lean:12:0: error: project axiom declaration MAT009.auditor_false diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/mutant-source.lean.txt b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/mutant-source.lean.txt new file mode 100644 index 0000000..78864d2 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom auditor_false : False + +end MAT009 diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/result.json b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/result.json new file mode 100644 index 0000000..4d6453f --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/result.json @@ -0,0 +1,79 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work", + "exit_code": 0, + "label": "build-00-SplitModel", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work", + "exit_code": 0, + "label": "build-01-DiagnosticFirstOwner", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work", + "exit_code": 0, + "label": "build-02-TypedConsumer", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work", + "exit_code": 0, + "label": "build-03-ExactTypes", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work", + "exit_code": 1, + "label": "build-04-LeanAudit", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "4278f4c415257c90ba3e5597f4b4af78f41dc260b235a72f1455d297a003f54d" + } + ], + "expected_observation": true, + "mutant_sha256": "37a6f5c7d10db455c6dbdc5ad35119d4fb7821875d15f33f0ce50e80ee0c8ba8", + "mutation": "ordinary_false_axiom", + "observed_exit_code": 1, + "observed_last_job": "build-04-LeanAudit" +} diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/DiagnosticFirstOwner.lean b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/DiagnosticFirstOwner.lean new file mode 100644 index 0000000..7283ce6 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/DiagnosticFirstOwner.lean @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some first + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/ExactTypes.lean b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/ExactTypes.lean new file mode 100644 index 0000000..7e5be3e --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/ExactTypes.lean @@ -0,0 +1,98 @@ +import TypedConsumer + +/-! +Independent typed uses of the intended MAT009 model propositions. A theorem +with the same name but a weaker type, such as `True`, cannot satisfy these +consumers. These are statements about eligible-row mathematical models only. +-/ + +namespace MAT009.ExactTypes +open MAT009 + +example (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := + M009_R1_initial parent role campaign lab reason + +example (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := + M009_R2_assignment_overwrite s row + +example (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := + M009_R3_cross_role_trigger s row + +example (s : State) (row : Row) (role : Role) + (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := + M009_R4_stickiness s row role campaign lab reason + +example (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := + M009_R5_final_set_intersection s + +example (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := + M009_R5_parent_union s + +example (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := + M009_R6_arbitrary_finite_scan parent rows role campaign lab reason + +example (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign := + M009_R6_latest_owner parent rows campaign + +example (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := + M009_R6_final_leakage_iff parent rows + +example : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := + M009_R7_nonvacuous + +example (registry : MAT009.Diagnostic.Registry) + (updates : List (String × MAT009.Diagnostic.Owner)) + (key : String) (first : MAT009.Diagnostic.Owner) + (h : registry key = some first) : + (MAT009.Diagnostic.scan registry updates) key = some first := + MAT009.Diagnostic.scan_first_owner_sticky registry updates key first h + +end MAT009.ExactTypes diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/LeanAudit.lean b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/LeanAudit.lean new file mode 100644 index 0000000..897b509 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/LeanAudit.lean @@ -0,0 +1,66 @@ +import ExactTypes +import Lean + +/-! +Enumerate every declaration whose origin is a MAT009 proof module, including +helpers and typed consumers. The script that runs this module checks the +inventory. `collectAxioms` traverses each declaration's logical dependencies. +-/ + +open Lean Elab Command + +run_cmd do + let env ← getEnv + let origins := #[ + `SplitModel, `DiagnosticFirstOwner, `TypedConsumer, `ExactTypes, + env.mainModule + ] + for mod in origins do + unless mod == env.mainModule || (env.getModuleIdx? mod).isSome do + throwError "missing required imported module {mod}" + logInfo m!"MAT009_MODULE {mod}" + for mod in env.header.moduleNames do + logInfo m!"MAT009_IMPORT {mod}" + let allowed := #[`propext, `Quot.sound, `Classical.choice] + let mut seen : Nat := 0 + let mut theorems : Nat := 0 + let declarations := env.checked.get.constants.toList.mergeSort fun a b => + decide (a.1.toString ≤ b.1.toString) + for (name, info) in declarations do + let origin := match env.getModuleIdxFor? name with + | some idx => env.header.moduleNames[idx.toNat]! + | none => env.mainModule + if origins.contains origin then + seen := seen + 1 + if info matches .thmInfo _ then + theorems := theorems + 1 + let generated := name.toString.endsWith "_cstage1" || + name.toString.endsWith "_cstage2" || + (name.toString.splitOn "._closed_").length > 1 || + (name.toString.splitOn "._elambda_").length > 1 + if info matches .axiomInfo _ then + unless generated do + throwError "project axiom declaration {name}" + let axioms ← collectAxioms name + let unsafeDef : Bool := match info with + | .defnInfo d => d.safety == DefinitionSafety.unsafe + | _ => false + for ax in axioms do + unless allowed.contains ax || generated do + throwError "unapproved transitive axiom {ax} in {name} (origin {origin})" + if unsafeDef && !generated then + throwError "unsafe project definition {name}" + let row := Json.mkObj [ + ("origin", toJson origin.toString), + ("declaration", toJson name.toString), + ("kind", toJson (if generated then "compiler_auxiliary" else + if info matches .thmInfo _ then "theorem" else "non_theorem")), + ("is_axiom", toJson (info matches .axiomInfo _)), + ("unsafe_definition", toJson unsafeDef), + ("type", toJson (← liftTermElabM do + pure (← Lean.Meta.ppExpr info.type).pretty)), + ("axioms", toJson (axioms.map Name.toString))] + logInfo m!"MAT009_DECL {row.compress}" + if seen == 0 || theorems == 0 then + throwError "empty proof inventory" + logInfo m!"MAT009_AUDIT declarations={seen} theorems={theorems}" diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/SplitModel.lean b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/SplitModel.lean new file mode 100644 index 0000000..78864d2 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/SplitModel.lean @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom auditor_false : False + +end MAT009 diff --git a/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/TypedConsumer.lean b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/TypedConsumer.lean new file mode 100644 index 0000000..2158aca --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/TypedConsumer.lean @@ -0,0 +1,65 @@ +import SplitModel +import DiagnosticFirstOwner + +/-! +A separate import consumer for the MAT009 split model. These declarations +type-check the public R1–R7 interface and derive blocked outcomes from the +generic finite-scan and parent-reason theorems. +-/ + +namespace MAT009.Consumer + +#check M009_R1_initial +#check M009_R2_assignment_overwrite +#check M009_R3_cross_role_trigger +#check M009_R4_stickiness +#check M009_R5_final_set_intersection +#check M009_R5_parent_union +#check M009_R6_cross_trigger_in_finite_scan +#check M009_R6_arbitrary_finite_scan +#check M009_R6_latest_owner +#check M009_R6_parent_reason_survives +#check M009_R6_final_leakage_iff +#check M009_R7_accepted_example +#check M009_R7_rejected_example +#check M009_R7_nonvacuous +#check MAT009.Diagnostic.scan_first_owner_sticky + +theorem parent_reason_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (reason : String) (h : parent reason) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + exact ⟨reason, M009_R6_parent_reason_survives parent rows reason h⟩ + +theorem shared_campaign_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (campaign : String) + (htrain : ∃ row ∈ rows, + row.role = .train ∧ row.campaign = campaign) + (hholdout : ∃ row ∈ rows, + row.role = .holdout ∧ row.campaign = campaign) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + refine ⟨leakageReason, Or.inr ?_⟩ + exact (M009_R6_final_leakage_iff parent rows).2 + (Or.inl ⟨campaign, htrain, hholdout⟩) + +#print axioms M009_R1_initial +#print axioms M009_R2_assignment_overwrite +#print axioms M009_R3_cross_role_trigger +#print axioms M009_R4_stickiness +#print axioms M009_R5_final_set_intersection +#print axioms M009_R5_parent_union +#print axioms M009_R6_cross_trigger_in_finite_scan +#print axioms M009_R6_arbitrary_finite_scan +#print axioms M009_R6_latest_owner +#print axioms M009_R6_parent_reason_survives +#print axioms M009_R6_final_leakage_iff +#print axioms M009_R7_accepted_example +#print axioms M009_R7_rejected_example +#print axioms M009_R7_nonvacuous +#print axioms parent_reason_blocks_any_scan +#print axioms shared_campaign_blocks_any_scan +#print axioms MAT009.Diagnostic.scan_first_owner_sticky +#print axioms MAT009.Diagnostic.first_owner_not_last_writer + +end MAT009.Consumer diff --git a/formal/sonification/mat009/audit/negative-probe-001/result.json b/formal/sonification/mat009/audit/negative-probe-001/result.json new file mode 100644 index 0000000..a137214 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/result.json @@ -0,0 +1,28 @@ +{ + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "results": [ + { + "expected_observation": true, + "mutant_sha256": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "mutation": "weaken_final_leakage", + "observed_exit_code": 1, + "observed_last_job": "build-02-TypedConsumer" + }, + { + "expected_observation": true, + "mutant_sha256": "37a6f5c7d10db455c6dbdc5ad35119d4fb7821875d15f33f0ce50e80ee0c8ba8", + "mutation": "ordinary_false_axiom", + "observed_exit_code": 1, + "observed_last_job": "build-04-LeanAudit" + }, + { + "expected_observation": true, + "mutant_sha256": "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71", + "mutation": "auxiliary_named_false_axiom", + "observed_exit_code": 0, + "observed_last_job": "build-04-LeanAudit" + } + ], + "source_candidate_unmodified": true, + "status": "PASS" +} diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..85516a3 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/build-02-TypedConsumer.stdout @@ -0,0 +1,68 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff : True +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +TypedConsumer.lean:43:9: error: function expected at + M009_R6_final_leakage_iff +term has type + True +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' does not depend on any axioms +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, sorryAx, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/mutant-source.lean.txt b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/mutant-source.lean.txt new file mode 100644 index 0000000..bd8b105 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/mutant-source.lean.txt @@ -0,0 +1,369 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff : True := by trivial + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/result.json b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/result.json new file mode 100644 index 0000000..57af96d --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/result.json @@ -0,0 +1,51 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work", + "exit_code": 0, + "label": "build-00-SplitModel", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work", + "exit_code": 0, + "label": "build-01-DiagnosticFirstOwner", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work", + "exit_code": 1, + "label": "build-02-TypedConsumer", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743" + } + ], + "expected_observation": true, + "mutant_sha256": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "mutation": "weaken_final_leakage", + "observed_exit_code": 1, + "observed_last_job": "build-02-TypedConsumer" +} diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/DiagnosticFirstOwner.lean b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/DiagnosticFirstOwner.lean new file mode 100644 index 0000000..7283ce6 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/DiagnosticFirstOwner.lean @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some first + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/ExactTypes.lean b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/ExactTypes.lean new file mode 100644 index 0000000..7e5be3e --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/ExactTypes.lean @@ -0,0 +1,98 @@ +import TypedConsumer + +/-! +Independent typed uses of the intended MAT009 model propositions. A theorem +with the same name but a weaker type, such as `True`, cannot satisfy these +consumers. These are statements about eligible-row mathematical models only. +-/ + +namespace MAT009.ExactTypes +open MAT009 + +example (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := + M009_R1_initial parent role campaign lab reason + +example (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := + M009_R2_assignment_overwrite s row + +example (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := + M009_R3_cross_role_trigger s row + +example (s : State) (row : Row) (role : Role) + (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := + M009_R4_stickiness s row role campaign lab reason + +example (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := + M009_R5_final_set_intersection s + +example (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := + M009_R5_parent_union s + +example (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := + M009_R6_arbitrary_finite_scan parent rows role campaign lab reason + +example (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign := + M009_R6_latest_owner parent rows campaign + +example (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := + M009_R6_final_leakage_iff parent rows + +example : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := + M009_R7_nonvacuous + +example (registry : MAT009.Diagnostic.Registry) + (updates : List (String × MAT009.Diagnostic.Owner)) + (key : String) (first : MAT009.Diagnostic.Owner) + (h : registry key = some first) : + (MAT009.Diagnostic.scan registry updates) key = some first := + MAT009.Diagnostic.scan_first_owner_sticky registry updates key first h + +end MAT009.ExactTypes diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/LeanAudit.lean b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/LeanAudit.lean new file mode 100644 index 0000000..897b509 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/LeanAudit.lean @@ -0,0 +1,66 @@ +import ExactTypes +import Lean + +/-! +Enumerate every declaration whose origin is a MAT009 proof module, including +helpers and typed consumers. The script that runs this module checks the +inventory. `collectAxioms` traverses each declaration's logical dependencies. +-/ + +open Lean Elab Command + +run_cmd do + let env ← getEnv + let origins := #[ + `SplitModel, `DiagnosticFirstOwner, `TypedConsumer, `ExactTypes, + env.mainModule + ] + for mod in origins do + unless mod == env.mainModule || (env.getModuleIdx? mod).isSome do + throwError "missing required imported module {mod}" + logInfo m!"MAT009_MODULE {mod}" + for mod in env.header.moduleNames do + logInfo m!"MAT009_IMPORT {mod}" + let allowed := #[`propext, `Quot.sound, `Classical.choice] + let mut seen : Nat := 0 + let mut theorems : Nat := 0 + let declarations := env.checked.get.constants.toList.mergeSort fun a b => + decide (a.1.toString ≤ b.1.toString) + for (name, info) in declarations do + let origin := match env.getModuleIdxFor? name with + | some idx => env.header.moduleNames[idx.toNat]! + | none => env.mainModule + if origins.contains origin then + seen := seen + 1 + if info matches .thmInfo _ then + theorems := theorems + 1 + let generated := name.toString.endsWith "_cstage1" || + name.toString.endsWith "_cstage2" || + (name.toString.splitOn "._closed_").length > 1 || + (name.toString.splitOn "._elambda_").length > 1 + if info matches .axiomInfo _ then + unless generated do + throwError "project axiom declaration {name}" + let axioms ← collectAxioms name + let unsafeDef : Bool := match info with + | .defnInfo d => d.safety == DefinitionSafety.unsafe + | _ => false + for ax in axioms do + unless allowed.contains ax || generated do + throwError "unapproved transitive axiom {ax} in {name} (origin {origin})" + if unsafeDef && !generated then + throwError "unsafe project definition {name}" + let row := Json.mkObj [ + ("origin", toJson origin.toString), + ("declaration", toJson name.toString), + ("kind", toJson (if generated then "compiler_auxiliary" else + if info matches .thmInfo _ then "theorem" else "non_theorem")), + ("is_axiom", toJson (info matches .axiomInfo _)), + ("unsafe_definition", toJson unsafeDef), + ("type", toJson (← liftTermElabM do + pure (← Lean.Meta.ppExpr info.type).pretty)), + ("axioms", toJson (axioms.map Name.toString))] + logInfo m!"MAT009_DECL {row.compress}" + if seen == 0 || theorems == 0 then + throwError "empty proof inventory" + logInfo m!"MAT009_AUDIT declarations={seen} theorems={theorems}" diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/SplitModel.lean b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/SplitModel.lean new file mode 100644 index 0000000..bd8b105 --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/SplitModel.lean @@ -0,0 +1,369 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff : True := by trivial + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/TypedConsumer.lean b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/TypedConsumer.lean new file mode 100644 index 0000000..2158aca --- /dev/null +++ b/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/TypedConsumer.lean @@ -0,0 +1,65 @@ +import SplitModel +import DiagnosticFirstOwner + +/-! +A separate import consumer for the MAT009 split model. These declarations +type-check the public R1–R7 interface and derive blocked outcomes from the +generic finite-scan and parent-reason theorems. +-/ + +namespace MAT009.Consumer + +#check M009_R1_initial +#check M009_R2_assignment_overwrite +#check M009_R3_cross_role_trigger +#check M009_R4_stickiness +#check M009_R5_final_set_intersection +#check M009_R5_parent_union +#check M009_R6_cross_trigger_in_finite_scan +#check M009_R6_arbitrary_finite_scan +#check M009_R6_latest_owner +#check M009_R6_parent_reason_survives +#check M009_R6_final_leakage_iff +#check M009_R7_accepted_example +#check M009_R7_rejected_example +#check M009_R7_nonvacuous +#check MAT009.Diagnostic.scan_first_owner_sticky + +theorem parent_reason_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (reason : String) (h : parent reason) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + exact ⟨reason, M009_R6_parent_reason_survives parent rows reason h⟩ + +theorem shared_campaign_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (campaign : String) + (htrain : ∃ row ∈ rows, + row.role = .train ∧ row.campaign = campaign) + (hholdout : ∃ row ∈ rows, + row.role = .holdout ∧ row.campaign = campaign) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + refine ⟨leakageReason, Or.inr ?_⟩ + exact (M009_R6_final_leakage_iff parent rows).2 + (Or.inl ⟨campaign, htrain, hholdout⟩) + +#print axioms M009_R1_initial +#print axioms M009_R2_assignment_overwrite +#print axioms M009_R3_cross_role_trigger +#print axioms M009_R4_stickiness +#print axioms M009_R5_final_set_intersection +#print axioms M009_R5_parent_union +#print axioms M009_R6_cross_trigger_in_finite_scan +#print axioms M009_R6_arbitrary_finite_scan +#print axioms M009_R6_latest_owner +#print axioms M009_R6_parent_reason_survives +#print axioms M009_R6_final_leakage_iff +#print axioms M009_R7_accepted_example +#print axioms M009_R7_rejected_example +#print axioms M009_R7_nonvacuous +#print axioms parent_reason_blocks_any_scan +#print axioms shared_campaign_blocks_any_scan +#print axioms MAT009.Diagnostic.scan_first_owner_sticky +#print axioms MAT009.Diagnostic.first_owner_not_last_writer + +end MAT009.Consumer diff --git a/formal/sonification/mat009/audit/negative_probe.py b/formal/sonification/mat009/audit/negative_probe.py new file mode 100644 index 0000000..758aabb --- /dev/null +++ b/formal/sonification/mat009/audit/negative_probe.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python3 +"""Independent isolated Lean mutations; never edit the candidate proof files.""" + +from __future__ import annotations + +import hashlib +import json +import os +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[4] +PROOF = ROOT / "formal/sonification/mat009/lean" +OUT = Path(__file__).resolve().parent / "negative-probe-001" +LEAN = Path("/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean") +MODULES = ("SplitModel", "DiagnosticFirstOwner", "TypedConsumer", "ExactTypes", "LeanAudit") + + +def sha(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def mutate(name: str, source: str) -> str: + if name == "weaken_final_leakage": + start = source.index("theorem M009_R6_final_leakage_iff") + end = source.index("\ndef noParent", start) + return ( + source[:start] + + "theorem M009_R6_final_leakage_iff : True := by trivial\n" + + source[end:] + ) + if name == "ordinary_false_axiom": + return source.replace("\nend MAT009\n", "\naxiom auditor_false : False\n\nend MAT009\n") + if name == "auxiliary_named_false_axiom": + return source.replace( + "\nend MAT009\n", + "\naxiom auditor_false_cstage1 : False\n" + "theorem auditor_false_proof_cstage1 : False := auditor_false_cstage1\n" + "\nend MAT009\n", + ) + raise AssertionError(name) + + +def run_case(name: str) -> dict: + case = OUT / name + case.mkdir() + work = case / "work" + work.mkdir() + original = (PROOF / "SplitModel.lean").read_text() + mutant = mutate(name, original) + if mutant == original: + raise AssertionError("empty mutation") + for module in MODULES: + raw = mutant if module == "SplitModel" else (PROOF / f"{module}.lean").read_text() + (work / f"{module}.lean").write_text(raw) + (case / "mutant-source.lean.txt").write_text(mutant) + env = {**os.environ, "LEAN_PATH": str(work), "TMPDIR": str(work)} + commands = [] + for number, module in enumerate(MODULES): + argv = [str(LEAN), "--error=warning", "-o", str(work / f"{module}.olean"), f"{module}.lean"] + result = subprocess.run(argv, cwd=work, env=env, capture_output=True, timeout=180) + label = f"build-{number:02d}-{module}" + (case / f"{label}.stdout").write_bytes(result.stdout) + (case / f"{label}.stderr").write_bytes(result.stderr) + commands.append( + { + "label": label, + "argv": argv, + "cwd": str(work), + "exit_code": result.returncode, + "stdout_sha256": sha(result.stdout), + "stderr_sha256": sha(result.stderr), + } + ) + if result.returncode != 0: + break + observed = commands[-1] + if name == "weaken_final_leakage": + expected = observed["label"] == "build-02-TypedConsumer" and observed["exit_code"] != 0 + elif name == "ordinary_false_axiom": + expected = observed["label"] == "build-04-LeanAudit" and observed["exit_code"] != 0 + else: + expected = observed["label"] == "build-04-LeanAudit" and observed["exit_code"] == 0 + details = {} + if name == "auxiliary_named_false_axiom" and expected: + lines = (case / "build-04-LeanAudit.stdout").read_text().splitlines() + rows = [ + json.loads(line.removeprefix("MAT009_DECL ")) + for line in lines + if line.startswith("MAT009_DECL ") + ] + details["disguised_declarations"] = [ + row for row in rows if "auditor_false" in row["declaration"] + ] + expected = ( + expected + and len(details["disguised_declarations"]) == 2 + and all( + row["kind"] == "compiler_auxiliary" for row in details["disguised_declarations"] + ) + ) + details["audit_summary"] = [line for line in lines if line.startswith("MAT009_AUDIT ")] + report = { + "mutation": name, + "mutant_sha256": sha(mutant.encode()), + "observed_last_job": observed["label"], + "observed_exit_code": observed["exit_code"], + "expected_observation": expected, + "commands": commands, + **details, + } + (case / "result.json").write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + return report + + +def main() -> int: + OUT.mkdir(exist_ok=False) + results = [ + run_case(name) + for name in ("weaken_final_leakage", "ordinary_false_axiom", "auxiliary_named_false_axiom") + ] + report = { + "status": "PASS" if all(x["expected_observation"] for x in results) else "FAIL", + "source_candidate_unmodified": True, + "lean_executable_sha256": sha(LEAN.read_bytes()), + "results": [ + { + key: x[key] + for key in ( + "mutation", + "mutant_sha256", + "observed_last_job", + "observed_exit_code", + "expected_observation", + ) + } + for x in results + ], + } + (OUT / "result.json").write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + print(json.dumps(report, sort_keys=True)) + return 0 if report["status"] == "PASS" else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/formal/sonification/mat009/audit/negative_probe.stderr b/formal/sonification/mat009/audit/negative_probe.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/negative_probe.stdout b/formal/sonification/mat009/audit/negative_probe.stdout new file mode 100644 index 0000000..15cd5b1 --- /dev/null +++ b/formal/sonification/mat009/audit/negative_probe.stdout @@ -0,0 +1 @@ +{"lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", "results": [{"expected_observation": true, "mutant_sha256": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", "mutation": "weaken_final_leakage", "observed_exit_code": 1, "observed_last_job": "build-02-TypedConsumer"}, {"expected_observation": true, "mutant_sha256": "37a6f5c7d10db455c6dbdc5ad35119d4fb7821875d15f33f0ce50e80ee0c8ba8", "mutation": "ordinary_false_axiom", "observed_exit_code": 1, "observed_last_job": "build-04-LeanAudit"}, {"expected_observation": true, "mutant_sha256": "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71", "mutation": "auxiliary_named_false_axiom", "observed_exit_code": 0, "observed_last_job": "build-04-LeanAudit"}], "source_candidate_unmodified": true, "status": "PASS"} diff --git a/formal/sonification/mat009/audit/nominal-finite.stderr b/formal/sonification/mat009/audit/nominal-finite.stderr new file mode 100644 index 0000000..529216b --- /dev/null +++ b/formal/sonification/mat009/audit/nominal-finite.stderr @@ -0,0 +1,4 @@ +---------------------------------------------------------------------- +Ran 18 tests in 0.307s + +OK diff --git a/formal/sonification/mat009/audit/nominal-finite.stdout b/formal/sonification/mat009/audit/nominal-finite.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/nominal-lean-receipt.stderr b/formal/sonification/mat009/audit/nominal-lean-receipt.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/nominal-lean-receipt.stdout b/formal/sonification/mat009/audit/nominal-lean-receipt.stdout new file mode 100644 index 0000000..5b9973f --- /dev/null +++ b/formal/sonification/mat009/audit/nominal-lean-receipt.stdout @@ -0,0 +1 @@ +{"AUDIT_ACCEPTED": "OPEN", "REFINEMENT_PROVED": "OPEN", "named_model_theorems": 22, "status": "MAT009_LEAN_EVIDENCE_BOUND", "toolchain_imports": 1303} diff --git a/formal/sonification/mat009/audit/nominal-negative-receipt.stderr b/formal/sonification/mat009/audit/nominal-negative-receipt.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/nominal-negative-receipt.stdout b/formal/sonification/mat009/audit/nominal-negative-receipt.stdout new file mode 100644 index 0000000..b95b717 --- /dev/null +++ b/formal/sonification/mat009/audit/nominal-negative-receipt.stdout @@ -0,0 +1 @@ +{"REFINEMENT_PROVED": "OPEN", "detected": 6, "failed_development_attempts_retained": 2, "status": "MAT009_NEGATIVE_EVIDENCE_BOUND"} diff --git a/formal/sonification/mat009/audit/nominal-source-binding.stderr b/formal/sonification/mat009/audit/nominal-source-binding.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/nominal-source-binding.stdout b/formal/sonification/mat009/audit/nominal-source-binding.stdout new file mode 100644 index 0000000..631c1d9 --- /dev/null +++ b/formal/sonification/mat009/audit/nominal-source-binding.stdout @@ -0,0 +1 @@ +{"assurance": "SOURCE_SYNTAX_PINNED_ONLY", "commit": "0758a96360726aafbb07abed34620eda178407ae", "direct_parent_sha256": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", "refinement_to_cpython": "OPEN", "selected_functions": 8, "status": "SOURCE_SYNTAX_MATCH", "tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", "target_sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", "tree": "a6a03e1227e666680d656b886201ee9dde9de32d"} diff --git a/formal/sonification/mat009/audit/nominal-source-receipts.stderr b/formal/sonification/mat009/audit/nominal-source-receipts.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/nominal-source-receipts.stdout b/formal/sonification/mat009/audit/nominal-source-receipts.stdout new file mode 100644 index 0000000..b965f29 --- /dev/null +++ b/formal/sonification/mat009/audit/nominal-source-receipts.stdout @@ -0,0 +1 @@ +{"REFINEMENT_PROVED": "OPEN", "receipt_count": 4, "status": "MAT009_SOURCE_FINITE_RECEIPTS_BOUND"} diff --git a/formal/sonification/mat009/audit/report.json b/formal/sonification/mat009/audit/report.json new file mode 100644 index 0000000..2fb85de --- /dev/null +++ b/formal/sonification/mat009/audit/report.json @@ -0,0 +1,827 @@ +{ + "auditor_committed_or_pushed": false, + "auditor_file_scope": "formal/sonification/mat009/audit/**", + "candidate_commit": "94a357284408e6bc24cfb9b2d49e9d4144791042", + "executions": { + "fresh_lean_jobs": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--version" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "lean-version", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "build-00-SplitModel", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "build-01-DiagnosticFirstOwner", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "build-02-TypedConsumer", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "build-03-ExactTypes", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "build-04-LeanAudit", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "21d9dcb639ded4b2c3047045038ff0d3a3c216f2c1f57554d0832fb81e7042cc" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "IndependentAxioms.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/independent-replay-001/work", + "exit_code": 0, + "label": "independent-axioms", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "18eddea3912a9320626a48d5eb5e2a91dec2c04c371fb9914479feabc8f1ee0d" + } + ], + "isolated_lean_mutation_jobs": { + "auxiliary_named_false_axiom": { + "exit_code": 0, + "expected_observation": true, + "jobs": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "exit_code": 0, + "label": "build-00-SplitModel", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "exit_code": 0, + "label": "build-01-DiagnosticFirstOwner", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "exit_code": 0, + "label": "build-02-TypedConsumer", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "exit_code": 0, + "label": "build-03-ExactTypes", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "exit_code": 0, + "label": "build-04-LeanAudit", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "1383254714bf4ce3d9cf3d50c98f8af57f86e59b1b0caf36a09ad6192b8a9167" + } + ], + "last_job": "build-04-LeanAudit", + "mutant_sha256": "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71", + "raw_log_directory": "formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom" + }, + "ordinary_false_axiom": { + "exit_code": 1, + "expected_observation": true, + "jobs": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work", + "exit_code": 0, + "label": "build-00-SplitModel", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work", + "exit_code": 0, + "label": "build-01-DiagnosticFirstOwner", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work", + "exit_code": 0, + "label": "build-02-TypedConsumer", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work", + "exit_code": 0, + "label": "build-03-ExactTypes", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom/work", + "exit_code": 1, + "label": "build-04-LeanAudit", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "4278f4c415257c90ba3e5597f4b4af78f41dc260b235a72f1455d297a003f54d" + } + ], + "last_job": "build-04-LeanAudit", + "mutant_sha256": "37a6f5c7d10db455c6dbdc5ad35119d4fb7821875d15f33f0ce50e80ee0c8ba8", + "raw_log_directory": "formal/sonification/mat009/audit/negative-probe-001/ordinary_false_axiom" + }, + "weaken_final_leakage": { + "exit_code": 1, + "expected_observation": true, + "jobs": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work", + "exit_code": 0, + "label": "build-00-SplitModel", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work", + "exit_code": 0, + "label": "build-01-DiagnosticFirstOwner", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage/work", + "exit_code": 1, + "label": "build-02-TypedConsumer", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743" + } + ], + "last_job": "build-02-TypedConsumer", + "mutant_sha256": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "raw_log_directory": "formal/sonification/mat009/audit/negative-probe-001/weaken_final_leakage" + } + }, + "nominal_verifiers_and_finite": [ + { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/source/source_bind.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1" + }, + "exit_code": 0, + "label": "nominal-source-binding", + "stderr": "formal/sonification/mat009/audit/nominal-source-binding.stderr", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout": "formal/sonification/mat009/audit/nominal-source-binding.stdout", + "stdout_sha256": "5a3750fcbab24ba5889a7a5439b5445d7484ac50a497ab546df22139462902b7" + }, + { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/verify_evidence.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1" + }, + "exit_code": 0, + "label": "nominal-source-receipts", + "stderr": "formal/sonification/mat009/audit/nominal-source-receipts.stderr", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout": "formal/sonification/mat009/audit/nominal-source-receipts.stdout", + "stdout_sha256": "2c408e885fa4ac144dbd6bffc148095f09f3e67db1fb054de95953589e56c816" + }, + { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/lean/verify.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1" + }, + "exit_code": 0, + "label": "nominal-lean-receipt", + "stderr": "formal/sonification/mat009/audit/nominal-lean-receipt.stderr", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout": "formal/sonification/mat009/audit/nominal-lean-receipt.stdout", + "stdout_sha256": "c419e181e2b8bbecddb22cfbf98b41d848f22f725d939ecafcafaf326fea32d4" + }, + { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/lean/verify_negative.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1" + }, + "exit_code": 0, + "label": "nominal-negative-receipt", + "stderr": "formal/sonification/mat009/audit/nominal-negative-receipt.stderr", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout": "formal/sonification/mat009/audit/nominal-negative-receipt.stdout", + "stdout_sha256": "8cb3c759e0dd871f132cc1524700e3908fbc88e38b5b8e39901fcbd5d9f87c21" + }, + { + "argv": [ + "python3", + "-B", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_sonification_formal_mat009_split.py", + "-q" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1" + }, + "exit_code": 0, + "label": "nominal-finite", + "stderr": "formal/sonification/mat009/audit/nominal-finite.stderr", + "stderr_sha256": "74af5ce4fbba3c1ea3fd3d523f3e71d43ff1dde9fdf6191adc71aa5473892334", + "stdout": "formal/sonification/mat009/audit/nominal-finite.stdout", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + ], + "own_top_level": [ + { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/lean/check.py", + "--lean", + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--baseline-commit", + "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "--out", + "formal/sonification/mat009/audit/checker-replay-001" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "TMPDIR": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit" + }, + "exit_code": 0, + "label": "checker-replay-001", + "stderr": "formal/sonification/mat009/audit/checker-replay-001.stderr", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout": "formal/sonification/mat009/audit/checker-replay-001.stdout", + "stdout_sha256": "19725bf0a82bba5c79ad0e7a5423afda68a8b461b24c6f31ffe44fcd0bd975fa" + }, + { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/audit/independent_replay.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1" + }, + "exit_code": 0, + "label": "independent_replay", + "stderr": "formal/sonification/mat009/audit/independent_replay.stderr", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout": "formal/sonification/mat009/audit/independent_replay.stdout", + "stdout_sha256": "68c03f97be8c1927cd0c56098e9a8700cb2f40f0915a868e7aeb8dc00c001de2" + }, + { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/audit/negative_probe.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1" + }, + "exit_code": 0, + "label": "negative_probe", + "stderr": "formal/sonification/mat009/audit/negative_probe.stderr", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout": "formal/sonification/mat009/audit/negative_probe.stdout", + "stdout_sha256": "918195248cb309a150d021be2a1b9eb67b1a08208dc122ed969290267caeedf9" + }, + { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/audit/verification_probe.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1" + }, + "exit_code": 0, + "label": "verification_probe_002", + "stderr": "formal/sonification/mat009/audit/verification_probe_002.stderr", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout": "formal/sonification/mat009/audit/verification_probe_002.stdout", + "stdout_sha256": "5c1ebac7a0dbbd99c2b8dc9cae07359350058247b54b8036c7ed7c07541f64a4" + }, + { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/audit/independent_cpython.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1" + }, + "exit_code": 0, + "label": "independent_cpython", + "stderr": "formal/sonification/mat009/audit/independent_cpython.stderr", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout": "formal/sonification/mat009/audit/independent_cpython.stdout", + "stdout_sha256": "b22b18483e5f86380253b1ebb0f8f804134816572a63bc06aef34529ae2e36d1" + }, + { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/audit/archive_integrity.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1" + }, + "exit_code": 0, + "label": "archive_integrity", + "stderr": "formal/sonification/mat009/audit/archive_integrity.stderr", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout": "formal/sonification/mat009/audit/archive_integrity.stdout", + "stdout_sha256": "59b8919ff08091733522de2f7d9818340aac57e489a9e62e090a6b78ca57feb0" + }, + { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/audit/count_gate_driver.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "env_overrides": { + "PYTHONDONTWRITEBYTECODE": "1" + }, + "exit_code": 1, + "label": "count_gate", + "stderr": "formal/sonification/mat009/audit/count_gate.stderr", + "stderr_sha256": "0a5892f510ddb8e91568b3adb32660ccb8c909f1ba69ebde999bed818b07b62f", + "stdout": "formal/sonification/mat009/audit/count_gate.stdout", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + ], + "raw_logs_root": "formal/sonification/mat009/audit", + "source_and_receipt_negative_jobs": [ + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/source_drift_driver.py", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-002/source-drift" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "working-tree target differs", + "expected_rejection": true, + "label": "mutated-source", + "stderr_sha256": "021e7103eb994405fddeba20cd66b8ca666395754f4ee87291c8eade04adba96", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/verify_evidence.py", + "--evidence", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-002/source-receipts" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "receipt file inventory changed", + "expected_rejection": true, + "label": "missing-finite-stream", + "stderr_sha256": "fcce5190b7817e5decdc23ce4155c9f94d21c71c29e1888f23e942a4576855bc", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify.py", + "--attempt", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-002/lean-attempt" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "evidence file inventory changed", + "expected_rejection": true, + "label": "missing-lean-stream", + "stderr_sha256": "e8d665fbd4c7fc24de8d32efc6dd124738809c6c3e0d929ef9d5eb8d4cd46f44", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify_negative.py", + "--archive", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-002/negative-archive" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "archive file inventory changed", + "expected_rejection": true, + "label": "missing-negative-mutant", + "stderr_sha256": "a9e91f39be3d5749edd90f3cd159be517255a1b1d4374ea044f3f2e4d9f781ef", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/checker_mutant_driver.py", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-002/checker-result" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "stale proof input: SplitModel.lean", + "expected_rejection": true, + "label": "mutated-proof-checker", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "f91aba630e0c84a57297364e187a1f87c803c3f29734be08a8ce17e93ab62e6f" + } + ] + }, + "failed_audit_harness_attempt": { + "accepted_negative_replay": "verification-probe-002", + "cause": "Audit drivers initially lacked the repository import path; three receipt deletions still rejected.", + "detail": "formal/sonification/mat009/audit/verification-probe-001/result.json", + "exit_code": 1, + "raw_log": "formal/sonification/mat009/audit/verification_probe.stdout" + }, + "finding": { + "audit_summary": [ + "MAT009_AUDIT declarations=353 theorems=96" + ], + "boundary": "Current proof-source commit and fixed declaration counts reject this changed input; the standalone Lean audit gate is unsafe for future rebaselines.", + "component": "formal/sonification/mat009/lean/LeanAudit.lean:37", + "current_named_theorem_axiom_impact": "NONE_OBSERVED", + "description": "The audit labels declarations as compiler auxiliaries from user-controllable name suffixes and exempts that class from project-axiom and transitive-axiom checks.", + "fixed_count_gate_error": "complete declaration/theorem inventory changed", + "fixed_count_gate_mutation_exit_code": 1, + "id": "MAT009-AUDIT-001", + "integrated_checker_error": "stale proof input: SplitModel.lean", + "integrated_checker_mutation_exit_code": 1, + "lean_audit_exit_code": 0, + "logged_false_declarations": [ + { + "axioms": [ + "MAT009.auditor_false_cstage1" + ], + "declaration": "MAT009.auditor_false_cstage1", + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "False", + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.auditor_false_cstage1" + ], + "declaration": "MAT009.auditor_false_proof_cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "False", + "unsafe_definition": false + } + ], + "minimal_mutation": [ + "axiom auditor_false_cstage1 : False", + "theorem auditor_false_proof_cstage1 : False := auditor_false_cstage1" + ], + "mutant_splitmodel_sha256": "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71", + "ordinary_axiom_control_exit_code": 1, + "status": "CONFIRMED" + }, + "finite_scope": { + "archived_negative_cases_verified": 6, + "focused_unittest_methods": 18, + "four_row_role_campaign_lab_assignments": 4096, + "frozen_synthetic_controls": 14, + "full_pytest_receipt": { + "argv": [ + "python3", + "-m", + "pytest", + "-q" + ], + "checkout_commit": "94a357284408e6bc24cfb9b2d49e9d4144791042", + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "explicit_input_count": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "31f40469e07bb9d0da2a4e7c18cce59ee83d4b1e5243095535d76f212c6d4c8a", + "summary": "329 passed, 202 subtests passed" + }, + "independent_counterexamples": { + "builtin_same_text_reason_count": 7, + "clean_reasons": [], + "clean_status": "STRUCTURAL_ONLY_UNAUTHENTICATED", + "cpython_refinement": "OPEN", + "dict_subclass_exception": "RuntimeError", + "invalid_role_reasons": [ + "TRAIN_REQUIRES_BOTH_PHASES", + "UNDECLARED_TRAIN_HOLDOUT_ROLE" + ], + "parent_skip_reasons": [ + "BOTH_PHASES_REQUIRED_FOR_EACH_CAMPAIGN", + "MISSING_OR_INVALID_SOURCE_IDENTITIES" + ], + "physical_evidence_admitted": false, + "source_sha256": { + "mat_spec_008.py": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", + "mat_spec_009.py": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690" + }, + "status": "PASS_FOR_LISTED_CASES_ONLY", + "subclass_equal_text_unequal_hash_reasons": [], + "synthetic_control_count": 14, + "synthetic_integer_one_reasons": [], + "synthetic_true_reasons": [ + "SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT" + ], + "unhashable_string_exception": "TypeError" + } + }, + "limitations": [ + "No theorem establishes source-to-model or CPython refinement for MAT009 and MAT008.", + "R7's two-row structural witness is a model witness only; MAT009 requires both phases in each source split.", + "The Lean row model omits child skip guards, parent implementation, phases, receipts, diagnostics, and other child reasons.", + "Finite tests and archived execution receipts cover listed cases only; the full pytest receipt lists no explicit inputs.", + "Python subclass equality, hashing, dict methods, and exceptions escape the exact built-in refinement domain.", + "All candidate identities and digests are self-declared. No physical independence, prospective registration, or accuracy is authenticated." + ], + "model_scope": { + "arbitrary_finite_eligible_row_list": true, + "arbitrary_parent_reason_set": true, + "compiler_auxiliaries": 146, + "compiler_generated_axioms_in_nominal_inventory": [ + "MAT009.initial._elambda_1", + "MAT009.step._elambda_1" + ], + "declarations": 351, + "eligible_rows_only": true, + "exact_typed_consumer_compiled": true, + "false_or_weakened_named_theorem_found": false, + "logical_violations_in_nominal_declarations": [], + "named_theorems_independently_queried": 22, + "nonvacuity": "R7 supplies both structural and blocked model witnesses", + "theorems_including_generated": 95 + }, + "observed_head_after_additional_full_pytest_receipt": "c9d2b6f5ee7b0a23b10b5cfd4c495b461ccb17c9", + "production_files_modified_by_auditor": false, + "proof_identity": { + "all_proof_input_sha256": { + "DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "LeanAudit.lean": "7aeabffbd65357e4ea41d773950bc7b52c892c5347b259f51d6a3831296aced8", + "PROOF_NOTES.md": "660493388f779bd1fc38a30a8051596e05985250e08b5f51e5c226da7e354cbf", + "SplitModel.lean": "2d6f80e9749e846db5f7c54bcc189c1ae3f345e19677842c002c2bea69790795", + "TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa", + "check.py": "125041442f582e7fc254dc341926b4cfb935ac964057c930021366a950a5a108", + "lean-toolchain": "55e97be96000b5e9e290c9e74482e5e317861499a5540353ce845471bded8cea" + }, + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "module_sha256": { + "formal/sonification/mat009/lean/DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "formal/sonification/mat009/lean/ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "formal/sonification/mat009/lean/LeanAudit.lean": "7aeabffbd65357e4ea41d773950bc7b52c892c5347b259f51d6a3831296aced8", + "formal/sonification/mat009/lean/SplitModel.lean": "2d6f80e9749e846db5f7c54bcc189c1ae3f345e19677842c002c2bea69790795", + "formal/sonification/mat009/lean/TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa" + }, + "proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "toolchain_imports_verified": 1303 + }, + "retained_evidence": { + "failed_development_attempts_retained": 2, + "negative_files_verified": 97, + "negative_manifest_sha256": "6d99b5c41017d87922ffd01f3b34eccab692806ca38b760299371cbcc0d0750b", + "nominal_audit_stdout_matches_fresh_replay": true, + "nominal_files_verified": 23, + "nominal_manifest_sha256": "c068cb09fa08737a25bf49c17fa7cbca1e31dbbaa5ab388532b5529e1e41c817", + "receipt_deletion_controls_detected": 3, + "receipt_verifier_fail_open_found": false, + "source_receipts_verified": { + "mat009-finite-001": { + "exit_code": 0, + "input_count": 2, + "receipt_sha256": "b86b0b4ee2119ff0afffbd6ec575d9f2f3304fe6aaaa90cf3d6c43cae50f05e9" + }, + "mat009-pytest-001": { + "exit_code": 0, + "input_count": 3, + "receipt_sha256": "cd00d1ebda66b847432194d9b53ffa22060bfa518c6c6b99dc9e63ea1fe0996f" + }, + "mat009-ruff-source-001": { + "exit_code": 0, + "input_count": 2, + "receipt_sha256": "efe30f79371ca762ac498a06e7e49c7b330b644d6b8bcb2cfbc37a7e60c0b4fd" + }, + "mat009-source-bind-001": { + "exit_code": 0, + "input_count": 2, + "receipt_sha256": "e3c3793f25532f540ba20b79729c5f20ede2398470ed2ffa8d75705cb93c5606" + } + } + }, + "schema": "sonification-mat009-independent-audit-v1", + "scientific_boundary": { + "classifier_accuracy_proved": false, + "empirical_validation": "OPEN", + "heldout_accuracy": null, + "independence_authenticated": false, + "physical_evidence_admitted": false, + "receipt_digests_are_syntactic_assertions_only": true + }, + "source_identity": { + "commit": "0758a96360726aafbb07abed34620eda178407ae", + "direct_mat008_blob": "3117adbc3739c834f8203d5d2dd2b80d6caf862b", + "direct_mat008_sha256": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", + "mat009_blob": "c447f0ce76b91acf458221390ac4261166145a0b", + "mat009_sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", + "tag": "mat-spec-009-v0.1.0", + "tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", + "tree": "a6a03e1227e666680d656b886201ee9dde9de32d" + }, + "target": "MAT-009-VERIFY-001", + "verdicts": { + "audit": "FAIL", + "cpython_refinement": "OPEN", + "exact_model": "PASS", + "finite": "PASS", + "source_binding": "PASS" + } +} diff --git a/formal/sonification/mat009/audit/source_drift_driver.py b/formal/sonification/mat009/audit/source_drift_driver.py new file mode 100644 index 0000000..0dd571b --- /dev/null +++ b/formal/sonification/mat009/audit/source_drift_driver.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +"""Run the unmodified binder against an isolated mutated working source.""" + +from __future__ import annotations + +import importlib +import subprocess +import sys +from pathlib import Path +from unittest.mock import patch + +ROOT = Path(__file__).resolve().parents[4] +sys.path.insert(0, str(ROOT)) + +source_bind = importlib.import_module("formal.sonification.mat009.source.source_bind") + + +def frozen_git(*arguments: str) -> bytes: + return subprocess.run( + ["git", "-C", str(ROOT), *arguments], + check=True, + capture_output=True, + timeout=30, + ).stdout + + +def main() -> int: + isolated = Path(sys.argv[1]).resolve() + with patch.object(source_bind, "ROOT", isolated), patch.object(source_bind, "git", frozen_git): + source_bind.verify() + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/EVIDENCE_MANIFEST.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/EVIDENCE_MANIFEST.json new file mode 100644 index 0000000..6dec709 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/EVIDENCE_MANIFEST.json @@ -0,0 +1,30 @@ +{ + "files_sha256": { + "build-00-SplitModel.json": "34ce5cf3d1dc2c4f740ea0360be7eaeec34e619315b63cec306d04e58076115c", + "build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.json": "5fccb56c651f29766987206416ba9d02ea3b95b4bd43f0ee67d1d8a0854203fd", + "build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.json": "d55c0693f763865b7ebc254fbd86ec266e650e93e146cea17407b465ecded54e", + "build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "build-03-ExactTypes.json": "71ff2627b1b9224d97347d827e310a1c73d5f2ab9fa3113ec1e03ecb4e870780", + "build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.json": "50a6752ba2f65a5cea9a1cb436cef3fdda1b5ea8122cd9a15dd255e7b85cc392", + "build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.stdout": "21d9dcb639ded4b2c3047045038ff0d3a3c216f2c1f57554d0832fb81e7042cc", + "declarations.json": "b3b5211e5edbbf49ac083f520bede6fef89ac3faccfa93b1d563e710f5f2537f", + "lean-version.json": "891fd7e9d7ca7393779b1eafec93925d0eb39390da8bb66ed47d2d72a5bd8d5b", + "lean-version.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "lean-version.stdout": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b", + "named-axioms.json": "d726df048cf1d5d7528afe2838eaa8a05b31b6a10c3b2a34109380b4bf779b1f", + "result.json": "74ed460c20a7ddc98d53891fc3a34de63404169f40405fe08fbcac2e4b6d85b1", + "theorem-types.json": "8ebc9839c12845f0410085754b475d7dd0ebf6c218869eebe39f2484104ddf5b", + "toolchain-imports.json": "69c9e85cad9c3ec024130bd80dc3e1fa6351053f135304268741bf1f0fd1b2ad" + }, + "proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "schema": "sonification-mat009-lean-evidence-v1", + "scope": "checked eligible-row mathematical models; CPython refinement OPEN" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-00-SplitModel.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-00-SplitModel.json new file mode 100644 index 0000000..4bdb01e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-00-SplitModel.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-01-DiagnosticFirstOwner.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-01-DiagnosticFirstOwner.json new file mode 100644 index 0000000..0550d4e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-01-DiagnosticFirstOwner.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-02-TypedConsumer.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-02-TypedConsumer.json new file mode 100644 index 0000000..ca5d4d0 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-02-TypedConsumer.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-03-ExactTypes.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-03-ExactTypes.json new file mode 100644 index 0000000..68500a4 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-03-ExactTypes.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-04-LeanAudit.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-04-LeanAudit.json new file mode 100644 index 0000000..16c555a --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-04-LeanAudit.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "21d9dcb639ded4b2c3047045038ff0d3a3c216f2c1f57554d0832fb81e7042cc", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-04-LeanAudit.stdout new file mode 100644 index 0000000..cbccb8f --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/build-04-LeanAudit.stdout @@ -0,0 +1,1664 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.initial","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._closed_1._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.initial._elambda_1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.initial.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_3","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_4","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRow","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._closed_1._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.lastRole [] x = none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_2._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.leakageReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.leakageReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.noParent","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.noParent x = False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.noParent.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout ∧\n s.campaigns MAT009.Role.train \"SAME\" ∧ s.campaigns MAT009.Role.holdout \"SAME\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.overwrite_retains_both_split_memberships","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason ∧ ¬(MAT009.finalize s).childReason MAT009.leakageReason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_can_supply_leakage_reason","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (reason : String), s.parent reason → (MAT009.finalize s).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_reason_survives_finalization","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.scan s [] = s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_append","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key ↔\n s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), s.crossed → (MAT009.scan s rows).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_crossed_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.scan s rows)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_familyLeakage_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key ↔ s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_owner_last","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason ↔ s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.Role → String → Prop) → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.splitIntersection","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (members : MAT009.Role → String → Prop),\n MAT009.splitIntersection members = ∃ key, members MAT009.Role.train key ∧ members MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.splitIntersection.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.step","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.step._elambda_1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key ∨ role = row.role ∧ key = row.campaign,\n labs := fun role key => s.labs role key ∨ role = row.role ∧ key = row.lab,\n crossed := s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role,\n parent := s.parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.step.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String × MAT009.Diagnostic.Owner)) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (x : String) (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_15._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_16._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_17._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_18._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_19._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_20._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_21._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_AUDIT declarations=351 theorems=95 diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/declarations.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/declarations.json new file mode 100644 index 0000000..8fd605c --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/declarations.json @@ -0,0 +1,3321 @@ +[ + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Consumer.parent_reason_blocks_any_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "TypedConsumer", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Consumer.shared_campaign_blocks_any_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "TypedConsumer", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = campaign) \u2192\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = campaign) \u2192\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.Owner", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.Registry", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (x : String), MAT009.Diagnostic.empty x = none", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.first_owner_not_last_writer", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 String \u2192 MAT009.Diagnostic.Owner \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 String \u2192 MAT009.Diagnostic.Owner \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : Option MAT009.Diagnostic.Owner \u2192 Sort u_1) \u2192\n (x : Option MAT009.Diagnostic.Owner) \u2192\n (Unit \u2192 motive none) \u2192 ((first : MAT009.Diagnostic.Owner) \u2192 motive (some first)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : Option MAT009.Diagnostic.Owner \u2192 Sort u_1) \u2192\n (x : Option MAT009.Diagnostic.Owner) \u2192\n (Unit \u2192 motive none) \u2192 ((first : MAT009.Diagnostic.Owner) \u2192 motive (some first)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_first_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first \u2192 MAT009.Diagnostic.register registry identity candidate identity = some first", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_new_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none \u2192 MAT009.Diagnostic.register registry identity candidate identity = some candidate", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_other_identity", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key \u2260 identity \u2192 MAT009.Diagnostic.register registry identity candidate key = registry key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_preserves_existing", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.register registry identity candidate key = some first", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n (Unit \u2192 motive []) \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n (Unit \u2192 motive []) \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.scan_first_owner_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (updates : List (String \u00d7 MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.scan registry updates key = some first", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n (t : MAT009.Final) \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.childReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.childReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason \u2227 f.crossed \u2228 reason = MAT009.leakageReason \u2227 f.leakage)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.crossed", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.hasReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.hasReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason \u2228 f.childReason reason)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.leakage", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 Prop \u2192 Prop \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 Prop \u2192 Prop \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } \u2192\n parent = parent_1 \u2227 crossed = crossed_1 \u2227 leakage = leakage_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Final.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 \u2227 crossed = crossed_1 \u2227 leakage = leakage_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.Final} \u2192 v1 = v2 \u2192 MAT009.Final.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.Final \u2192 MAT009.Final \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.parent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n (t : MAT009.Final) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n (t : MAT009.Final) \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final),\n f.status = if \u2203 reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status_blocked_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final), f.status = MAT009.Status.blocked \u2194 \u2203 reason, f.hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status_structural_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated \u2194 \u2200 (reason : String), \u00acf.hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Final.status_structural_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {p : \u03b1 \u2192 Prop}, (\u00ac\u2203 x, p x) = \u2200 (x : \u03b1), \u00acp x", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R1_initial", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none \u2227\n \u00ac(MAT009.initial parent).campaigns role campaign \u2227\n \u00ac(MAT009.initial parent).labs role lab \u2227\n \u00ac(MAT009.initial parent).crossed \u2227 ((MAT009.initial parent).parent reason \u2194 parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R2_assignment_overwrite", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role \u2227\n (\u2200 (key : String), key \u2260 row.campaign \u2192 (MAT009.step s row).owner key = s.owner key) \u2227\n (\u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key \u2194 s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign) \u2227\n \u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key \u2194 s.labs role key \u2228 role = row.role \u2227 key = row.lab", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R3_cross_role_trigger", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed \u2194 s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R4_stickiness", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign \u2192 (MAT009.step s row).campaigns role campaign) \u2227\n (s.labs role lab \u2192 (MAT009.step s row).labs role lab) \u2227\n (s.crossed \u2192 (MAT009.step s row).crossed) \u2227\n (MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)) \u2227\n ((MAT009.step s row).parent reason \u2194 s.parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R5_final_set_intersection", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason \u2194\n (\u2203 key, s.campaigns MAT009.Role.train key \u2227 s.campaigns MAT009.Role.holdout key) \u2228\n \u2203 key, s.labs MAT009.Role.train key \u2227 s.labs MAT009.Role.holdout key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R5_parent_union", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason \u2194 s.parent MAT009.leakageReason \u2228 MAT009.familyLeakage s", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign \u2194\n \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = campaign) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab \u2194 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = lab) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).parent reason \u2194 parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_cross_trigger_in_finite_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (\u2203 previous, (MAT009.scan s before).owner row.campaign = some previous \u2227 previous \u2260 row.role) \u2192\n (MAT009.scan s (before ++ row :: after)).crossed", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason \u2194\n (\u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = key) \u2228\n \u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.lab = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.lab = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_latest_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R6_parent_reason_survives", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_accepted_example", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_nonvacuous", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(\u2203 rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) \u2227\n \u2203 rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_rejected_example", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.ReasonSet", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 (t : MAT009.Role) \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.holdout", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.holdout.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Role.holdout = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Role} \u2192 x = y \u2192 MAT009.Role.noConfusionType P x y", + "unsafe_definition": false + }, + { + "axioms": [ + "lcUnreachable" + ], + "declaration": "MAT009.Role.noConfusion._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Role} \u2192 x = y \u2192 MAT009.Role.noConfusionType P x y", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 _neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._lambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort v\u271d \u2192 MAT009.Role \u2192 MAT009.Role \u2192 Sort v\u271d", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat_toCtorIdx", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 (t : MAT009.Role) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 (t : MAT009.Role) \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.train", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.train.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Role.train = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.campaign", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n (t : MAT009.Row) \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.lab", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String \u2192 String \u2192 MAT009.Role \u2192 MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String \u2192 String \u2192 MAT009.Role \u2192 MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } \u2192\n campaign = campaign_1 \u2227 lab = lab_1 \u2227 role = role_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Row.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 \u2227 lab = lab_1 \u2227 role = role_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.Row} \u2192 v1 = v2 \u2192 MAT009.Row.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.Row \u2192 MAT009.Row \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n (t : MAT009.Row) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n (t : MAT009.Row) \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.role", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.campaigns", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Role \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n (t : MAT009.State) \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.crossed", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.labs", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Role \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(String \u2192 Option MAT009.Role) \u2192\n (MAT009.Role \u2192 String \u2192 Prop) \u2192 (MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop \u2192 MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(String \u2192 Option MAT009.Role) \u2192\n (MAT009.Role \u2192 String \u2192 Prop) \u2192 (MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop \u2192 MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {owner : String \u2192 Option MAT009.Role} {campaigns labs : MAT009.Role \u2192 String \u2192 Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String \u2192 Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role \u2192 String \u2192 Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } \u2192\n owner = owner_1 \u2227 campaigns = campaigns_1 \u2227 labs = labs_1 \u2227 crossed = crossed_1 \u2227 parent = parent_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.State.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (owner : String \u2192 Option MAT009.Role) (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String \u2192 Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role \u2192 String \u2192 Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 \u2227 campaigns = campaigns_1 \u2227 labs = labs_1 \u2227 crossed = crossed_1 \u2227 parent = parent_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (owner : String \u2192 Option MAT009.Role) (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.State} \u2192 v1 = v2 \u2192 MAT009.State.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.State \u2192 MAT009.State \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.owner", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.parent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n (t : MAT009.State) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n (t : MAT009.State) \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.blocked", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.blocked.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Status.blocked = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n (t : MAT009.Status) \u2192 motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Status} \u2192 x = y \u2192 MAT009.Status.noConfusionType P x y", + "unsafe_definition": false + }, + { + "axioms": [ + "lcUnreachable" + ], + "declaration": "MAT009.Status.noConfusion._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Status} \u2192 x = y \u2192 MAT009.Status.noConfusionType P x y", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 _neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort v\u271d \u2192 MAT009.Status \u2192 MAT009.Status \u2192 Sort v\u271d", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat_toCtorIdx", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 (t : MAT009.Status) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n (t : MAT009.Status) \u2192 motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.structuralOnlyUnauthenticated", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns \u2228 MAT009.splitIntersection s.labs)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage_step_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.finalize", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.finalize._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Final", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.finalize._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.finalize.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.initial", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._elambda_1", + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.initial._elambda_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.initial._elambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.initial.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [ + "lcProof" + ], + "declaration": "MAT009.instDecidableEqRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._proof_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx \u2192 x = y", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._proof_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Role), \u00acx.toCtorIdx = y.toCtorIdx \u2192 x = y \u2192 False", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [ + "lcProof" + ], + "declaration": "MAT009.instDecidableEqStatus._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._proof_3", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx \u2192 x = y", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._proof_4", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Status), \u00acx.toCtorIdx = y.toCtorIdx \u2192 x = y \u2192 False", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String), MAT009.lastRole [] x = none", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : Option MAT009.Role \u2192 Sort u_1) \u2192\n (x : Option MAT009.Role) \u2192 ((role : MAT009.Role) \u2192 motive (some role)) \u2192 (Unit \u2192 motive none) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : Option MAT009.Role \u2192 Sort u_1) \u2192\n (x : Option MAT009.Role) \u2192 ((role : MAT009.Role) \u2192 motive (some role)) \u2192 (Unit \u2192 motive none) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_2", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_2._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.noParent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.noParent._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.ReasonSet", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.noParent._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.noParent.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String), MAT009.noParent x = False", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.overwrite_retains_both_split_memberships", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout \u2227\n s.campaigns MAT009.Role.train \"SAME\" \u2227 s.campaigns MAT009.Role.holdout \"SAME\"", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.parent_can_supply_leakage_reason", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason \u2227 \u00ac(MAT009.finalize s).childReason MAT009.leakageReason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.parent_reason_survives_finalization", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (reason : String), s.parent reason \u2192 (MAT009.finalize s).hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.scan._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.scan._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State), MAT009.scan s [] = s", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (Unit \u2192 motive []) \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (Unit \u2192 motive []) \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.scan_append", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key \u2194\n s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {a b : \u03b1}, (a = b) = (b = a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, ((a \u2228 b) \u2228 c) = (a \u2228 b \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, (a \u2228 b \u2228 c) = (b \u2228 a \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_8", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b : Prop}, (a \u2228 b) = (b \u2228 a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_crossed_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row), s.crossed \u2192 (MAT009.scan s rows).crossed", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_familyLeakage_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.scan s rows)", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.scan_labs_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key \u2194 s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {a b : \u03b1}, (a = b) = (b = a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, ((a \u2228 b) \u2228 c) = (a \u2228 b \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, (a \u2228 b \u2228 c) = (b \u2228 a \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_8", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b : Prop}, (a \u2228 b) = (b \u2228 a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_owner_last", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan_parent", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason \u2194 s.parent reason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.splitIntersection", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.splitIntersection.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (members : MAT009.Role \u2192 String \u2192 Prop),\n MAT009.splitIntersection members = \u2203 key, members MAT009.Role.train key \u2227 members MAT009.Role.holdout key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.step", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._elambda_1", + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.step._elambda_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.step._elambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.step.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign,\n labs := fun role key => s.labs role key \u2228 role = row.role \u2227 key = row.lab,\n crossed := s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role,\n parent := s.parent }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) (h_1 : Unit \u2192 motive [])\n (h_2 :\n (identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) (h_1 : Unit \u2192 motive [])\n (h_2 :\n (identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n motive [] \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n motive [] \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 String \u2192 Sort u_1) (x : String) (h_1 : (x : String) \u2192 motive [] x)\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 String \u2192 Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) \u2192 motive [] x)\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : MAT009.Role \u2192 Sort u_1) \u2192\n (x : MAT009.Role) \u2192 (Unit \u2192 motive MAT009.Role.train) \u2192 (Unit \u2192 motive MAT009.Role.holdout) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.match_1.\u00ab_@\u00bb.SplitModel._hyg.109._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : MAT009.Role \u2192 Sort u_1) \u2192\n (x : MAT009.Role) \u2192 (Unit \u2192 motive MAT009.Role.train) \u2192 (Unit \u2192 motive MAT009.Role.holdout) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_13._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_14._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_13._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_14._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_15._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_16._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_17._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_18._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_19._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_20._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_21._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : MAT009.Status \u2192 Sort u_1) \u2192\n (x : MAT009.Status) \u2192\n (Unit \u2192 motive MAT009.Status.blocked) \u2192 (Unit \u2192 motive MAT009.Status.structuralOnlyUnauthenticated) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.match_1.\u00ab_@\u00bb.SplitModel._hyg.882._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : MAT009.Status \u2192 Sort u_1) \u2192\n (x : MAT009.Status) \u2192\n (Unit \u2192 motive MAT009.Status.blocked) \u2192 (Unit \u2192 motive MAT009.Status.structuralOnlyUnauthenticated) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 Sort u_1) (h_1 : Unit \u2192 motive [])\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit \u2192 motive [])\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192 motive [] \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192 motive [] \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + } +] diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/lean-version.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/lean-version.json new file mode 100644 index 0000000..10f4b46 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/lean-version.json @@ -0,0 +1,12 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--version" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b", + "timed_out": false, + "timeout_seconds": 30 +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/lean-version.stderr b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/lean-version.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/lean-version.stdout b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/lean-version.stdout new file mode 100644 index 0000000..507e58d --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/lean-version.stdout @@ -0,0 +1 @@ +Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release) diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/named-axioms.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/named-axioms.json new file mode 100644 index 0000000..41676d1 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/named-axioms.json @@ -0,0 +1,62 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Consumer.shared_campaign_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Diagnostic.first_owner_not_last_writer": [ + "propext" + ], + "MAT009.Diagnostic.scan_first_owner_sticky": [ + "propext" + ], + "MAT009.M009_R1_initial": [ + "propext" + ], + "MAT009.M009_R2_assignment_overwrite": [ + "propext" + ], + "MAT009.M009_R3_cross_role_trigger": [], + "MAT009.M009_R4_stickiness": [], + "MAT009.M009_R5_final_set_intersection": [ + "propext" + ], + "MAT009.M009_R5_parent_union": [ + "propext" + ], + "MAT009.M009_R6_arbitrary_finite_scan": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_cross_trigger_in_finite_scan": [ + "propext" + ], + "MAT009.M009_R6_final_leakage_iff": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_latest_owner": [ + "propext" + ], + "MAT009.M009_R6_parent_reason_survives": [], + "MAT009.M009_R7_accepted_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_nonvacuous": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_rejected_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ] +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/result.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/result.json new file mode 100644 index 0000000..cb922b8 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/result.json @@ -0,0 +1,55 @@ +{ + "AUDIT_ACCEPTED": "OPEN", + "DIFFERENTIAL_TESTED": "NOT_EXECUTED", + "MODEL_PROVED": "PASS_FOR_SCOPED_MATHEMATICAL_MODEL", + "REFINEMENT_PROVED": "OPEN", + "baseline_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "compiler_auxiliary_count": 146, + "completed_utc": "2026-11-10T01:00:17.065909+00:00", + "declaration_count": 351, + "external_import_count": 1303, + "input_sha256": { + "DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "LeanAudit.lean": "7aeabffbd65357e4ea41d773950bc7b52c892c5347b259f51d6a3831296aced8", + "PROOF_NOTES.md": "660493388f779bd1fc38a30a8051596e05985250e08b5f51e5c226da7e354cbf", + "SplitModel.lean": "2d6f80e9749e846db5f7c54bcc189c1ae3f345e19677842c002c2bea69790795", + "TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa", + "check.py": "125041442f582e7fc254dc341926b4cfb935ac964057c930021366a950a5a108", + "lean-toolchain": "55e97be96000b5e9e290c9e74482e5e317861499a5540353ce845471bded8cea" + }, + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "lean_version": "Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release)", + "logical_axioms": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "named_intended_theorems": [ + "MAT009.Consumer.parent_reason_blocks_any_scan", + "MAT009.Consumer.shared_campaign_blocks_any_scan", + "MAT009.Diagnostic.first_owner_not_last_writer", + "MAT009.Diagnostic.register_first_owner", + "MAT009.Diagnostic.register_new_owner", + "MAT009.Diagnostic.register_other_identity", + "MAT009.Diagnostic.register_preserves_existing", + "MAT009.Diagnostic.scan_first_owner_sticky", + "MAT009.M009_R1_initial", + "MAT009.M009_R2_assignment_overwrite", + "MAT009.M009_R3_cross_role_trigger", + "MAT009.M009_R4_stickiness", + "MAT009.M009_R5_final_set_intersection", + "MAT009.M009_R5_parent_union", + "MAT009.M009_R6_arbitrary_finite_scan", + "MAT009.M009_R6_cross_trigger_in_finite_scan", + "MAT009.M009_R6_final_leakage_iff", + "MAT009.M009_R6_latest_owner", + "MAT009.M009_R6_parent_reason_survives", + "MAT009.M009_R7_accepted_example", + "MAT009.M009_R7_nonvacuous", + "MAT009.M009_R7_rejected_example" + ], + "started_utc": "2026-11-10T00:59:57.311697+00:00", + "status": "PASS", + "theorem_declaration_count_including_generated": 95 +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/theorem-types.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/theorem-types.json new file mode 100644 index 0000000..1eb358e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/theorem-types.json @@ -0,0 +1,24 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "MAT009.Consumer.shared_campaign_blocks_any_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = campaign) \u2192\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = campaign) \u2192\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "MAT009.Diagnostic.first_owner_not_last_writer": "MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")", + "MAT009.Diagnostic.register_first_owner": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first \u2192 MAT009.Diagnostic.register registry identity candidate identity = some first", + "MAT009.Diagnostic.register_new_owner": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none \u2192 MAT009.Diagnostic.register registry identity candidate identity = some candidate", + "MAT009.Diagnostic.register_other_identity": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key \u2260 identity \u2192 MAT009.Diagnostic.register registry identity candidate key = registry key", + "MAT009.Diagnostic.register_preserves_existing": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.register registry identity candidate key = some first", + "MAT009.Diagnostic.scan_first_owner_sticky": "\u2200 (registry : MAT009.Diagnostic.Registry) (updates : List (String \u00d7 MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.scan registry updates key = some first", + "MAT009.M009_R1_initial": "\u2200 (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none \u2227\n \u00ac(MAT009.initial parent).campaigns role campaign \u2227\n \u00ac(MAT009.initial parent).labs role lab \u2227\n \u00ac(MAT009.initial parent).crossed \u2227 ((MAT009.initial parent).parent reason \u2194 parent reason)", + "MAT009.M009_R2_assignment_overwrite": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role \u2227\n (\u2200 (key : String), key \u2260 row.campaign \u2192 (MAT009.step s row).owner key = s.owner key) \u2227\n (\u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key \u2194 s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign) \u2227\n \u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key \u2194 s.labs role key \u2228 role = row.role \u2227 key = row.lab", + "MAT009.M009_R3_cross_role_trigger": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed \u2194 s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role", + "MAT009.M009_R4_stickiness": "\u2200 (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign \u2192 (MAT009.step s row).campaigns role campaign) \u2227\n (s.labs role lab \u2192 (MAT009.step s row).labs role lab) \u2227\n (s.crossed \u2192 (MAT009.step s row).crossed) \u2227\n (MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)) \u2227\n ((MAT009.step s row).parent reason \u2194 s.parent reason)", + "MAT009.M009_R5_final_set_intersection": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason \u2194\n (\u2203 key, s.campaigns MAT009.Role.train key \u2227 s.campaigns MAT009.Role.holdout key) \u2228\n \u2203 key, s.labs MAT009.Role.train key \u2227 s.labs MAT009.Role.holdout key", + "MAT009.M009_R5_parent_union": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason \u2194 s.parent MAT009.leakageReason \u2228 MAT009.familyLeakage s", + "MAT009.M009_R6_arbitrary_finite_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign \u2194\n \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = campaign) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab \u2194 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = lab) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).parent reason \u2194 parent reason)", + "MAT009.M009_R6_cross_trigger_in_finite_scan": "\u2200 (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (\u2203 previous, (MAT009.scan s before).owner row.campaign = some previous \u2227 previous \u2260 row.role) \u2192\n (MAT009.scan s (before ++ row :: after)).crossed", + "MAT009.M009_R6_final_leakage_iff": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason \u2194\n (\u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = key) \u2228\n \u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.lab = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.lab = key", + "MAT009.M009_R6_latest_owner": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign", + "MAT009.M009_R6_parent_reason_survives": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason", + "MAT009.M009_R7_accepted_example": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated", + "MAT009.M009_R7_nonvacuous": "(\u2203 rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) \u2227\n \u2203 rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked", + "MAT009.M009_R7_rejected_example": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/toolchain-imports.json b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/toolchain-imports.json new file mode 100644 index 0000000..e56b85e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/lean-attempt/toolchain-imports.json @@ -0,0 +1,5214 @@ +{ + "Init": { + "relative_path": "lib/lean/Init.olean", + "sha256": "f14f6c9ea0d9eb2a6fe7bdad84a6610657db3d006805708c1a62ac72b676e944" + }, + "Init.BinderNameHint": { + "relative_path": "lib/lean/Init/BinderNameHint.olean", + "sha256": "87ad3f24763ab6293e9907bd53fd2c87397a1bcc41741d496530391424f397f0" + }, + "Init.BinderPredicates": { + "relative_path": "lib/lean/Init/BinderPredicates.olean", + "sha256": "b87d6204d662e2164c4ccac16ffe6ef34c17e46473219f7615a8e5a902f88399" + }, + "Init.ByCases": { + "relative_path": "lib/lean/Init/ByCases.olean", + "sha256": "a446cd54c7d9b5cd764bac51e0e86bdbfd92cceb559a0ce174c8bfdd0880031f" + }, + "Init.Classical": { + "relative_path": "lib/lean/Init/Classical.olean", + "sha256": "146557a1d2b3d89dccc8a37db0eaf2ca41b7e8b7e9699cc1d2040209ab2d5206" + }, + "Init.Coe": { + "relative_path": "lib/lean/Init/Coe.olean", + "sha256": "8264daae9323339b7a0e4648e9054bc4d6bfa2ed2efe3bbf60f3ed4c85ededf1" + }, + "Init.Control": { + "relative_path": "lib/lean/Init/Control.olean", + "sha256": "02b03cb26d015878cb086d2aa9619d028653c4d7b13f7d27defa18c526f59acf" + }, + "Init.Control.Basic": { + "relative_path": "lib/lean/Init/Control/Basic.olean", + "sha256": "770f96586bd33c585cba7ae023b9ba455fdbcc6656008a7ae44921a2a381e673" + }, + "Init.Control.EState": { + "relative_path": "lib/lean/Init/Control/EState.olean", + "sha256": "bf304f9ebac42bc1e0604ed85fd34ccfbfb1d48c36a0378264daa004c7b1663a" + }, + "Init.Control.Except": { + "relative_path": "lib/lean/Init/Control/Except.olean", + "sha256": "2df44aacfe3c18de279a500ce89ca07fdaae3ac41ee5e13753f675ffcee590bf" + }, + "Init.Control.ExceptCps": { + "relative_path": "lib/lean/Init/Control/ExceptCps.olean", + "sha256": "abf85a131ec12cc4943351cd8e94d25a8ea643d8aed05e3174ddf102a92c82ab" + }, + "Init.Control.Id": { + "relative_path": "lib/lean/Init/Control/Id.olean", + "sha256": "3bdbaf6aab9ebd5bc7f69df7ea3817d60fe3e93621ceac45998aeada2ab0f2fb" + }, + "Init.Control.Lawful": { + "relative_path": "lib/lean/Init/Control/Lawful.olean", + "sha256": "d0e4de63caa049aa63032c262df55cb6e05decd6a639b3197d03a94bfb9cf630" + }, + "Init.Control.Lawful.Basic": { + "relative_path": "lib/lean/Init/Control/Lawful/Basic.olean", + "sha256": "2e5796aeb855144054fe96c87df8c1942fe57363ca46616dd713602e9e83008e" + }, + "Init.Control.Lawful.Instances": { + "relative_path": "lib/lean/Init/Control/Lawful/Instances.olean", + "sha256": "3a42743efc08488094315361697052bbea44791dc9b26bb42a7687be82351798" + }, + "Init.Control.Lawful.Lemmas": { + "relative_path": "lib/lean/Init/Control/Lawful/Lemmas.olean", + "sha256": "872c79b884079a180f2cb4efe5d5ccfd86e8231040ccf0286fdc0ae3e48de6cb" + }, + "Init.Control.Option": { + "relative_path": "lib/lean/Init/Control/Option.olean", + "sha256": "2fd4fd3d76c35d38f22bbd43287b2034db3fc09e9db40a72d64766fc2e1a27cf" + }, + "Init.Control.Reader": { + "relative_path": "lib/lean/Init/Control/Reader.olean", + "sha256": "0ee81ccf6c24215ac02fbddbc47f9d0ec88154c747938db879dc176e84cab35c" + }, + "Init.Control.State": { + "relative_path": "lib/lean/Init/Control/State.olean", + "sha256": "9967249936b6e2882f7c6551ed25b8c11c499e5146884f43c851019a9212b58e" + }, + "Init.Control.StateCps": { + "relative_path": "lib/lean/Init/Control/StateCps.olean", + "sha256": "a7e465f72965884c566492bf128ce366f9b6259feb3ff78a2dc7941276668910" + }, + "Init.Control.StateRef": { + "relative_path": "lib/lean/Init/Control/StateRef.olean", + "sha256": "4c48d97631e2c887a9109f0a3b11930e960674722db2d7ec96228ebb4cebc397" + }, + "Init.Conv": { + "relative_path": "lib/lean/Init/Conv.olean", + "sha256": "27e368664cd48cc7db0b6d8b936fcf3bd3b0c8652d67c7d72ed1a70e481c2cae" + }, + "Init.Core": { + "relative_path": "lib/lean/Init/Core.olean", + "sha256": "325d3e1934d1e99dbf7bde7643d6b1a582e0e98a2bc67156ecbfb1e044c81b62" + }, + "Init.Data": { + "relative_path": "lib/lean/Init/Data.olean", + "sha256": "e0fb356d8ff226c74733d563a2fddfd5d3f9031353f07eab9316189729ea0b05" + }, + "Init.Data.AC": { + "relative_path": "lib/lean/Init/Data/AC.olean", + "sha256": "c31d122ca9a36ebccfade139b5d01a27520cfe5da9c13fbcee0de6afc18e6e2e" + }, + "Init.Data.Array": { + "relative_path": "lib/lean/Init/Data/Array.olean", + "sha256": "628b1fe1e5028d01279c0e4b94f8a75a5404c5c2c62f56cb0f2f93e949b871fe" + }, + "Init.Data.Array.Attach": { + "relative_path": "lib/lean/Init/Data/Array/Attach.olean", + "sha256": "17dd10a433d8c5eefec2380008930b9db90cf5baaf6a111862d248280489809b" + }, + "Init.Data.Array.Basic": { + "relative_path": "lib/lean/Init/Data/Array/Basic.olean", + "sha256": "c1b3ecb3200b55fd9c0f508d6a70518cad1e6cd68e3333d6363ac275efa290b4" + }, + "Init.Data.Array.BasicAux": { + "relative_path": "lib/lean/Init/Data/Array/BasicAux.olean", + "sha256": "498f1b5994a45cd4303c9a5a1252d20f1706d7227fd6068a54a21102c4ecb49d" + }, + "Init.Data.Array.BinSearch": { + "relative_path": "lib/lean/Init/Data/Array/BinSearch.olean", + "sha256": "c8ffd80ccccd8119ba40ef890a3408310abd6535ecb282e8ecd8f8b943dad63a" + }, + "Init.Data.Array.Bootstrap": { + "relative_path": "lib/lean/Init/Data/Array/Bootstrap.olean", + "sha256": "d22a9ec6e5a01f844321cfd7ecfba9f02f0d15cffd6e7667315e36caaf2f4d5d" + }, + "Init.Data.Array.Count": { + "relative_path": "lib/lean/Init/Data/Array/Count.olean", + "sha256": "5cac2d9caf60f31946dcc2b3ecacde3f52d6c143dd91504af2245e9203360700" + }, + "Init.Data.Array.DecidableEq": { + "relative_path": "lib/lean/Init/Data/Array/DecidableEq.olean", + "sha256": "61699c7b47f0fe3ceabab22f86fad529d0c53c229168e2eb5a4c81b3b44161da" + }, + "Init.Data.Array.Erase": { + "relative_path": "lib/lean/Init/Data/Array/Erase.olean", + "sha256": "a39e0a7704569c26626a57596aa4838b835eb5940a90874febcd53aed46c3676" + }, + "Init.Data.Array.Extract": { + "relative_path": "lib/lean/Init/Data/Array/Extract.olean", + "sha256": "d3ae74a38b69aaf4e3f7cf247e3b51d97845035076f21c37f9516f17dec53115" + }, + "Init.Data.Array.FinRange": { + "relative_path": "lib/lean/Init/Data/Array/FinRange.olean", + "sha256": "ccdba2d4e97ed32f04ea6d66ffa24cd4667d3c17e923939d251b12b8c156ff0a" + }, + "Init.Data.Array.Find": { + "relative_path": "lib/lean/Init/Data/Array/Find.olean", + "sha256": "60374792eaf3e1c935911342aadc2e0fe2c2df226d1b2ffeead456d396242565" + }, + "Init.Data.Array.GetLit": { + "relative_path": "lib/lean/Init/Data/Array/GetLit.olean", + "sha256": "7500dfd2f61932caa3bb61dff522cea1d043f9d52f875df9ca9377cb5be6ae00" + }, + "Init.Data.Array.InsertIdx": { + "relative_path": "lib/lean/Init/Data/Array/InsertIdx.olean", + "sha256": "0885128103fece2609d3de7d95170ead99c2422e3b2611efc17ad64d13c54b93" + }, + "Init.Data.Array.InsertionSort": { + "relative_path": "lib/lean/Init/Data/Array/InsertionSort.olean", + "sha256": "00eeffee6c9c944e626b54aa1ba80e2817ee0d6d72a58b4504ed5d6150963199" + }, + "Init.Data.Array.Lemmas": { + "relative_path": "lib/lean/Init/Data/Array/Lemmas.olean", + "sha256": "6d70a718a88e0f5e3a2fbf58ab9a927086ecb80cc131ca4daf61b8373b29bc7e" + }, + "Init.Data.Array.Lex": { + "relative_path": "lib/lean/Init/Data/Array/Lex.olean", + "sha256": "dcfcf549b75b61784fc2761dd6ab27112a5f3f85635156ff45f17907241f873c" + }, + "Init.Data.Array.Lex.Basic": { + "relative_path": "lib/lean/Init/Data/Array/Lex/Basic.olean", + "sha256": "5099ffc811762f879efd0a8d2dc6a6f46b03aaf13e5d7198a40b028f84339f6a" + }, + "Init.Data.Array.Lex.Lemmas": { + "relative_path": "lib/lean/Init/Data/Array/Lex/Lemmas.olean", + "sha256": "edd3b29355f8877ba1d4baa7eb7191d19ec56b68e8caf7136e56562d46f2cf00" + }, + "Init.Data.Array.MapIdx": { + "relative_path": "lib/lean/Init/Data/Array/MapIdx.olean", + "sha256": "fa5fa7562d940a373cde8271701c1b1b6aa4ccc7685a7d8aee563bd6a531b023" + }, + "Init.Data.Array.Mem": { + "relative_path": "lib/lean/Init/Data/Array/Mem.olean", + "sha256": "6d8b81e87c3f6194010d50453930aef26a33d02836f577fdf528f96427fd2871" + }, + "Init.Data.Array.Monadic": { + "relative_path": "lib/lean/Init/Data/Array/Monadic.olean", + "sha256": "4c7ac2031c6b67e8904e378eab4f4e4e52a741464f759346c6bbadf358353040" + }, + "Init.Data.Array.OfFn": { + "relative_path": "lib/lean/Init/Data/Array/OfFn.olean", + "sha256": "269214e9ef1869f764ea7744d27f9bb5f2d88c06a199c35a523bcab485056514" + }, + "Init.Data.Array.Perm": { + "relative_path": "lib/lean/Init/Data/Array/Perm.olean", + "sha256": "df04ccb43fffbdfc14af5e01b9a288eba07cf33dfd934fefc7d3ee62380abbad" + }, + "Init.Data.Array.QSort": { + "relative_path": "lib/lean/Init/Data/Array/QSort.olean", + "sha256": "182e2fb5ccae0e4290f1df223f6da4fe8e4671735b1f8be5768f67aecd976a9b" + }, + "Init.Data.Array.Range": { + "relative_path": "lib/lean/Init/Data/Array/Range.olean", + "sha256": "470d0a04ec3f6acf4e1a4a17c0ac006ff4f4ca6a132e6fe75cb24a3422045edf" + }, + "Init.Data.Array.Set": { + "relative_path": "lib/lean/Init/Data/Array/Set.olean", + "sha256": "47765fffb2b0ff3eeb3b9fcdf1f872a1264fbecc6fd9fa3b3bcacb14305d21cc" + }, + "Init.Data.Array.Subarray": { + "relative_path": "lib/lean/Init/Data/Array/Subarray.olean", + "sha256": "a2b4eb8e9ff8708540ec1224bc150ec997f6b339fc526c8f905824dab5814eb1" + }, + "Init.Data.Array.Subarray.Split": { + "relative_path": "lib/lean/Init/Data/Array/Subarray/Split.olean", + "sha256": "e70f52b7a240f6f48ece84e6e5efe81be6f0aa59787d93877069acf4d299d6da" + }, + "Init.Data.Array.TakeDrop": { + "relative_path": "lib/lean/Init/Data/Array/TakeDrop.olean", + "sha256": "cb756a88720cd6633a931cc4cd278804391f1d4b6e7804fed40e0014f27250e4" + }, + "Init.Data.Array.Zip": { + "relative_path": "lib/lean/Init/Data/Array/Zip.olean", + "sha256": "57b72c19de8fc1a600d24da0a2ce3edc78620fc487668928f5092c62e6199bf8" + }, + "Init.Data.BEq": { + "relative_path": "lib/lean/Init/Data/BEq.olean", + "sha256": "fc264bbc09afcdee4cf301170287f97dce8426a1102c2c20a2b3324af470be03" + }, + "Init.Data.Basic": { + "relative_path": "lib/lean/Init/Data/Basic.olean", + "sha256": "320b6a318c7f47b88b4cc52a3dd10f1c253c4ba15882c0fba4d0b6cc8b258629" + }, + "Init.Data.BitVec": { + "relative_path": "lib/lean/Init/Data/BitVec.olean", + "sha256": "9806987569400445640812d3675deb3d56b79c12d42e8168aebba2d2d42ef3cd" + }, + "Init.Data.BitVec.Basic": { + "relative_path": "lib/lean/Init/Data/BitVec/Basic.olean", + "sha256": "263c59d8eecd1dca7acf46649c80ce9d7b5680064309b9eedc76d4ca02a03e34" + }, + "Init.Data.BitVec.BasicAux": { + "relative_path": "lib/lean/Init/Data/BitVec/BasicAux.olean", + "sha256": "1ba7804f2a9d1739a51b1e7dea3821a38743373b1072bf85c41d247cfa8bcbaa" + }, + "Init.Data.BitVec.Bitblast": { + "relative_path": "lib/lean/Init/Data/BitVec/Bitblast.olean", + "sha256": "c7663248b6910786438135f4eabd9f5fce7ddb61628c667345d04c4be6dda7b3" + }, + "Init.Data.BitVec.Folds": { + "relative_path": "lib/lean/Init/Data/BitVec/Folds.olean", + "sha256": "b4d4aa0cfd3f346fd1f6361552afcf5245668c55fd2d0ad1ebf467f841ae20d0" + }, + "Init.Data.BitVec.Lemmas": { + "relative_path": "lib/lean/Init/Data/BitVec/Lemmas.olean", + "sha256": "c11aebc16adf6f6fdd8d3a9dcb74b295034999579793c2f4eb79b044fccd618e" + }, + "Init.Data.Bool": { + "relative_path": "lib/lean/Init/Data/Bool.olean", + "sha256": "24c3fa2ac49e5f1681100130790a5f322bed745e47b503e25ff49b7a3c5f6d68" + }, + "Init.Data.ByteArray": { + "relative_path": "lib/lean/Init/Data/ByteArray.olean", + "sha256": "3c0fa93b6b78ea8b3733b02a83dca06a085b3938355811eee6c06cbdd0179a8e" + }, + "Init.Data.ByteArray.Basic": { + "relative_path": "lib/lean/Init/Data/ByteArray/Basic.olean", + "sha256": "f995de7efe27dc6573bf9cf32e2399ba4ee0659f0b64f07285bb15edbd8048fd" + }, + "Init.Data.Cast": { + "relative_path": "lib/lean/Init/Data/Cast.olean", + "sha256": "3413b2ca8a0098a6e572d7728ed1532eaa21ca10067197f3b214aeff2ccdd651" + }, + "Init.Data.Channel": { + "relative_path": "lib/lean/Init/Data/Channel.olean", + "sha256": "945114f1dd771f97d93cdac7466ff0ff1e0f1461bc4fda27b5f5b9715dcdc174" + }, + "Init.Data.Char": { + "relative_path": "lib/lean/Init/Data/Char.olean", + "sha256": "818aac23581c282c3f6d2f80775ac47ce6d31b55ce54b3d187b6ed4b8de8cc63" + }, + "Init.Data.Char.Basic": { + "relative_path": "lib/lean/Init/Data/Char/Basic.olean", + "sha256": "6ed0988e9f8e134dbc30d38ed257a44850e98d71b7d77d5a977f4297e085a0f1" + }, + "Init.Data.Char.Lemmas": { + "relative_path": "lib/lean/Init/Data/Char/Lemmas.olean", + "sha256": "030a6cdcb16360b9f90d072e40bd66ce8aafab43137dd9d03e82229ebec3ced9" + }, + "Init.Data.Fin": { + "relative_path": "lib/lean/Init/Data/Fin.olean", + "sha256": "e955ad0ee4c253aaf23086b1452740c2c9888c594b9c404bb34699868773dfe2" + }, + "Init.Data.Fin.Basic": { + "relative_path": "lib/lean/Init/Data/Fin/Basic.olean", + "sha256": "e4b2abb6d8a424da6e7ff21b0e71ead051c0605e76db3680888305ac128f5b55" + }, + "Init.Data.Fin.Bitwise": { + "relative_path": "lib/lean/Init/Data/Fin/Bitwise.olean", + "sha256": "e80029b17e55e5e4b917ef076545aa017bb7844bed24f7f3c376952d82f3e21b" + }, + "Init.Data.Fin.Fold": { + "relative_path": "lib/lean/Init/Data/Fin/Fold.olean", + "sha256": "8d618def1ed982a59898c72e714939d861836ea9f84fe4414677c4b7fac9295a" + }, + "Init.Data.Fin.Iterate": { + "relative_path": "lib/lean/Init/Data/Fin/Iterate.olean", + "sha256": "f6553fbf009244d2b848079f104ef424f9048ad5e5e45276169f58b674dbdf58" + }, + "Init.Data.Fin.Lemmas": { + "relative_path": "lib/lean/Init/Data/Fin/Lemmas.olean", + "sha256": "9fe597ce2f3edce6a67a4542d72bd0300cc643a484297fc8d61966a28b61935d" + }, + "Init.Data.Fin.Log2": { + "relative_path": "lib/lean/Init/Data/Fin/Log2.olean", + "sha256": "d4e9f3e05222a066c5fdc327065d7147d16a939ebcedf988b8e428bfd7a1d6a3" + }, + "Init.Data.Float": { + "relative_path": "lib/lean/Init/Data/Float.olean", + "sha256": "92478058b9b83eddef7ecea3797414d74db6e61e2b688e64ab7ba81df127b15a" + }, + "Init.Data.Float32": { + "relative_path": "lib/lean/Init/Data/Float32.olean", + "sha256": "2a37e1add33b9d6047350feaa9d87b913f1e58718bd5a3cb597d60e6573f9212" + }, + "Init.Data.FloatArray": { + "relative_path": "lib/lean/Init/Data/FloatArray.olean", + "sha256": "78c9b7500ea433aede3b8587af3bbbe727c8ebfd6f8a5942f6c0d14b0faa44b5" + }, + "Init.Data.FloatArray.Basic": { + "relative_path": "lib/lean/Init/Data/FloatArray/Basic.olean", + "sha256": "7169a26af51b7faaa9712ed85d9423a43b5c4f31ba4ccdbb3289eeaaf58e0afa" + }, + "Init.Data.Format": { + "relative_path": "lib/lean/Init/Data/Format.olean", + "sha256": "82528100ce60ae1eded58f45a0319b76ac7c80f9d834c60bec31cddd2a1f836b" + }, + "Init.Data.Format.Basic": { + "relative_path": "lib/lean/Init/Data/Format/Basic.olean", + "sha256": "7b7e7500d7a86ce98f996e4c6045c7fff49ee0efc72737cfc5ab4c284ad77f4a" + }, + "Init.Data.Format.Instances": { + "relative_path": "lib/lean/Init/Data/Format/Instances.olean", + "sha256": "b8bede2673426df8591cc8d2837854e12fd82f83132adcdb5d4fa6492b9f1d21" + }, + "Init.Data.Format.Macro": { + "relative_path": "lib/lean/Init/Data/Format/Macro.olean", + "sha256": "d4b42a5cd357e4c35a328183571bb8a919d2dba0e0241b081293c449b726ae35" + }, + "Init.Data.Format.Syntax": { + "relative_path": "lib/lean/Init/Data/Format/Syntax.olean", + "sha256": "3433640ca9aeb5ef96fda95bf9dc747d0feba236f3a3db2860f92970c5718882" + }, + "Init.Data.Function": { + "relative_path": "lib/lean/Init/Data/Function.olean", + "sha256": "17fa8cf9a33f44e97d1a3a8c77e086c567ef0520291421839b77b28fdbd2b8fa" + }, + "Init.Data.Hashable": { + "relative_path": "lib/lean/Init/Data/Hashable.olean", + "sha256": "0d9ba8712572cf7103ef0e4c1012f4c3d1b10bbc3f9d55409eb315ed87f26e7f" + }, + "Init.Data.Int": { + "relative_path": "lib/lean/Init/Data/Int.olean", + "sha256": "4628002a234694983f14e288745898d889aada1b0d9d9fbff5f3fb8dbb72c20a" + }, + "Init.Data.Int.Basic": { + "relative_path": "lib/lean/Init/Data/Int/Basic.olean", + "sha256": "926f11cf3beb5d66e06dc405f6aac7f39b38c440ba23baa26827ca79724b8eae" + }, + "Init.Data.Int.Bitwise": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise.olean", + "sha256": "527f601e3b6565c4e13a78e71c252c99f51b0203fba8e9a48bf61a6d702f7f77" + }, + "Init.Data.Int.Bitwise.Basic": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise/Basic.olean", + "sha256": "265104afaeebfc4163d1f1ab6bc8913ec7def48a6e0cf7c33a619e7c6b7996cd" + }, + "Init.Data.Int.Bitwise.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise/Lemmas.olean", + "sha256": "61fdbf3f93888946c2c76b36a1ac73246abd87048eb30a596d009a0dddfe3af0" + }, + "Init.Data.Int.Cooper": { + "relative_path": "lib/lean/Init/Data/Int/Cooper.olean", + "sha256": "607b77466cb24c6ae2b99b1bd054709dd7e315d0019d87854e45e588d2f4f061" + }, + "Init.Data.Int.DivMod": { + "relative_path": "lib/lean/Init/Data/Int/DivMod.olean", + "sha256": "0ac18881bb522630e818a1f973051dd26d51a7edfe6589132274694575627416" + }, + "Init.Data.Int.DivMod.Basic": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Basic.olean", + "sha256": "1bf5aad5de1a3d6931194060a4fe8fa304dced06404dd2815057179beecb7945" + }, + "Init.Data.Int.DivMod.Bootstrap": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Bootstrap.olean", + "sha256": "9f5e940c4fba88142e73ea864aee5257a1bf31566d3d67d1ebdd60967230d2c5" + }, + "Init.Data.Int.DivMod.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Lemmas.olean", + "sha256": "dbb9ae219e1f2072be3ed6986c5f713b1df79f563fab946fc903c7bcfdce7f48" + }, + "Init.Data.Int.Gcd": { + "relative_path": "lib/lean/Init/Data/Int/Gcd.olean", + "sha256": "294b7f9b1144098337d3b1eae9a286741c2a503388078bd601cf03bbc74e5af8" + }, + "Init.Data.Int.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/Lemmas.olean", + "sha256": "e447675a36f3fa775915d9c711e4172eb1575cb80d4f631ea9b4a0cf7319d791" + }, + "Init.Data.Int.LemmasAux": { + "relative_path": "lib/lean/Init/Data/Int/LemmasAux.olean", + "sha256": "f58eaab4a411b1dd8b2505d7b5479dc203c603ea9ee4a28dfc2e37ac6a1c50d3" + }, + "Init.Data.Int.Linear": { + "relative_path": "lib/lean/Init/Data/Int/Linear.olean", + "sha256": "a6f99acdf60bcb9b582ef87f01c9d53a76e61ea6466a7f4a9d5e4d5c9f564bc8" + }, + "Init.Data.Int.OfNat": { + "relative_path": "lib/lean/Init/Data/Int/OfNat.olean", + "sha256": "8b91634fcd25ef8639461730e11a2e30d7c0f479bd7c86064f1dbb0edf05d47c" + }, + "Init.Data.Int.Order": { + "relative_path": "lib/lean/Init/Data/Int/Order.olean", + "sha256": "32e716ca6845ff6b54befdb1d6fa157e6980471455c22c7c34a5fa1b206c5aaf" + }, + "Init.Data.Int.Pow": { + "relative_path": "lib/lean/Init/Data/Int/Pow.olean", + "sha256": "916584050412a63f5e067a8d86818a2576cd971f241d2bcce80da6ad9d2cebcd" + }, + "Init.Data.List": { + "relative_path": "lib/lean/Init/Data/List.olean", + "sha256": "a0b4ba4434de3cbe61e2009557a6b2c237e7ed24d903486b02efc2460594ebbe" + }, + "Init.Data.List.Attach": { + "relative_path": "lib/lean/Init/Data/List/Attach.olean", + "sha256": "1b460daad56a1203c465d63575d1fd1b0c417c9b22daa53d1239d3e3cf8858e3" + }, + "Init.Data.List.Basic": { + "relative_path": "lib/lean/Init/Data/List/Basic.olean", + "sha256": "45f40cdc05ba064b67aff84c6957f82c4a2e6edd0052fa508cc749e9d35999e1" + }, + "Init.Data.List.BasicAux": { + "relative_path": "lib/lean/Init/Data/List/BasicAux.olean", + "sha256": "210a850a3c6f96fb462b42a67920eed86b41cdfafd32adb39a272d4f66ab09fe" + }, + "Init.Data.List.Control": { + "relative_path": "lib/lean/Init/Data/List/Control.olean", + "sha256": "b082dae0a9caf27e9ebecc9d183598e091016f323b6b1c30942bfe9ac14915b6" + }, + "Init.Data.List.Count": { + "relative_path": "lib/lean/Init/Data/List/Count.olean", + "sha256": "37e1a1a86c77f09c1ae6f13af53e9f0fbc8dd888485e1796b1c0b2813904811a" + }, + "Init.Data.List.Erase": { + "relative_path": "lib/lean/Init/Data/List/Erase.olean", + "sha256": "2ff3cc2f53a947bba4110106d48bd8e6a746fbdbccda3d3168988377f9bf08d6" + }, + "Init.Data.List.FinRange": { + "relative_path": "lib/lean/Init/Data/List/FinRange.olean", + "sha256": "174b84f766bfad55861d5f9bf45051d705e4762491232c25589eda8491aee1fb" + }, + "Init.Data.List.Find": { + "relative_path": "lib/lean/Init/Data/List/Find.olean", + "sha256": "10dabc67b4e589018d889930fc75a663a75d91c7f083095e5892c3e359019d1d" + }, + "Init.Data.List.Impl": { + "relative_path": "lib/lean/Init/Data/List/Impl.olean", + "sha256": "1e62f8c4f057317bb61e73e76f39cbd3b699c7a45c168ab405f7c2cf35c3d2fe" + }, + "Init.Data.List.Lemmas": { + "relative_path": "lib/lean/Init/Data/List/Lemmas.olean", + "sha256": "ebcbcfb4dfc92e4eb9ece72b6c538b4809f96585313aef48cc91ed3e386f2ecc" + }, + "Init.Data.List.Lex": { + "relative_path": "lib/lean/Init/Data/List/Lex.olean", + "sha256": "3b9fb1bdab57ade29c2834da21d90ae802ccf7e58899b17ff487f6483c56ec72" + }, + "Init.Data.List.MapIdx": { + "relative_path": "lib/lean/Init/Data/List/MapIdx.olean", + "sha256": "bd024799a195c348a5937950048fddade6c7cc32ca43abc8e93a0d77c9593f3c" + }, + "Init.Data.List.MinMax": { + "relative_path": "lib/lean/Init/Data/List/MinMax.olean", + "sha256": "1fc6795971ac8f3530113326fb3e351626a4146db9c4772152b2ffe4a3bb81e1" + }, + "Init.Data.List.Monadic": { + "relative_path": "lib/lean/Init/Data/List/Monadic.olean", + "sha256": "82900949d78e7fc5b7c6415194cba03b2526409b350a39f923a78d9911132448" + }, + "Init.Data.List.Nat": { + "relative_path": "lib/lean/Init/Data/List/Nat.olean", + "sha256": "7963464ebb33af6223be0712ffb5bbe47c4587ae5380a61cbc5c6021baf9b422" + }, + "Init.Data.List.Nat.BEq": { + "relative_path": "lib/lean/Init/Data/List/Nat/BEq.olean", + "sha256": "fa52c59704dd8e1822d4b0257d670aedbb2f82017b74303bf358af42d494a450" + }, + "Init.Data.List.Nat.Basic": { + "relative_path": "lib/lean/Init/Data/List/Nat/Basic.olean", + "sha256": "745ae4e831f8597a5165d4dc9abc953c280a450a6547963f109c0fc18cbd6746" + }, + "Init.Data.List.Nat.Count": { + "relative_path": "lib/lean/Init/Data/List/Nat/Count.olean", + "sha256": "73ccebc5a9a303a8a9f2c9137d3fb60c3191b4d74c40370e53dc15e781536493" + }, + "Init.Data.List.Nat.Erase": { + "relative_path": "lib/lean/Init/Data/List/Nat/Erase.olean", + "sha256": "b8d0f4703d71d05efc7c94d8d2c2bad1278f1c65302ce0ee11275e93857f3b3c" + }, + "Init.Data.List.Nat.Find": { + "relative_path": "lib/lean/Init/Data/List/Nat/Find.olean", + "sha256": "73d6e91b894c9907bdb3a7087fa1fcc174fe4a96aac39055a797b84b8ec5f26a" + }, + "Init.Data.List.Nat.InsertIdx": { + "relative_path": "lib/lean/Init/Data/List/Nat/InsertIdx.olean", + "sha256": "5c5ac7ada578ca3a04908c1c6b94e2f12e684da28a3534fd8e2fb1712ba06a38" + }, + "Init.Data.List.Nat.Modify": { + "relative_path": "lib/lean/Init/Data/List/Nat/Modify.olean", + "sha256": "275e5291a6691082786680f93b2e0d09710e0fbcd9640b6503bbbf35041756aa" + }, + "Init.Data.List.Nat.Pairwise": { + "relative_path": "lib/lean/Init/Data/List/Nat/Pairwise.olean", + "sha256": "8aae1be95bb7c08d8e20bde2bdc46d737a4c54c6c132fb093782603e11f88e36" + }, + "Init.Data.List.Nat.Perm": { + "relative_path": "lib/lean/Init/Data/List/Nat/Perm.olean", + "sha256": "d34b546b7057199bf2b89b45908696cdc173bcbb8ff6e14c20e8553fce164014" + }, + "Init.Data.List.Nat.Range": { + "relative_path": "lib/lean/Init/Data/List/Nat/Range.olean", + "sha256": "56804bb0f398b27aba960edeff1d44703f3d59c67c72f540b9e4016fe7e005a3" + }, + "Init.Data.List.Nat.Sublist": { + "relative_path": "lib/lean/Init/Data/List/Nat/Sublist.olean", + "sha256": "cb179f24812905731bee16e0aabbf5eda0d6e1a07d693a0297798e3fab4316ab" + }, + "Init.Data.List.Nat.TakeDrop": { + "relative_path": "lib/lean/Init/Data/List/Nat/TakeDrop.olean", + "sha256": "86594d76cd6bca152ceabb5eaf14e7d2843b484cc2ae20233bf70eca4db3d470" + }, + "Init.Data.List.Notation": { + "relative_path": "lib/lean/Init/Data/List/Notation.olean", + "sha256": "231f63a53a24060f593b32f6321d2e5f1159bdb57172f5fd3e9ca2c38f137733" + }, + "Init.Data.List.OfFn": { + "relative_path": "lib/lean/Init/Data/List/OfFn.olean", + "sha256": "4d4a1feaf8df21b7567908a2723e0cd0bbb9ab1568a9cf1e6536c08a177c1119" + }, + "Init.Data.List.Pairwise": { + "relative_path": "lib/lean/Init/Data/List/Pairwise.olean", + "sha256": "6a00f9b67bb5554815fb9ca404ddf0f7df1fcb0c53d9b40a7de569f752a70779" + }, + "Init.Data.List.Perm": { + "relative_path": "lib/lean/Init/Data/List/Perm.olean", + "sha256": "16c720de1fc7adedfc438ed72845cdc53267779413765172a77e4540662d1a10" + }, + "Init.Data.List.Range": { + "relative_path": "lib/lean/Init/Data/List/Range.olean", + "sha256": "646ca36cfb7cb2359c5589af542f7b1714018cd2c2e06e705f38e8e69515ef29" + }, + "Init.Data.List.Sort": { + "relative_path": "lib/lean/Init/Data/List/Sort.olean", + "sha256": "c2718b7978559839c5c4493fa3a8efec0f89b75ba052319781ff102e2d4f874a" + }, + "Init.Data.List.Sort.Basic": { + "relative_path": "lib/lean/Init/Data/List/Sort/Basic.olean", + "sha256": "2358d6d69b08c0a229dd3fdc38598e300f65e534ac1a3db61495d2c68440b783" + }, + "Init.Data.List.Sort.Impl": { + "relative_path": "lib/lean/Init/Data/List/Sort/Impl.olean", + "sha256": "663f7c421f200455d1b5f73bbb1bc7698a83258cc2b8dd36d537f016f9eb9a77" + }, + "Init.Data.List.Sort.Lemmas": { + "relative_path": "lib/lean/Init/Data/List/Sort/Lemmas.olean", + "sha256": "8c31e71b3777de0363ff903a15fb77da2b64ca6e2a6df7e0f169c6fa6c68b9fc" + }, + "Init.Data.List.Sublist": { + "relative_path": "lib/lean/Init/Data/List/Sublist.olean", + "sha256": "626fc37b3fccd3ad01e524e497bed2e7470f69025ffb5c96477c5dda33cf93b8" + }, + "Init.Data.List.TakeDrop": { + "relative_path": "lib/lean/Init/Data/List/TakeDrop.olean", + "sha256": "6ad55d35f8158e3093612d2bd82b2fcc6e0e2692b89276374fbad91d05316236" + }, + "Init.Data.List.ToArray": { + "relative_path": "lib/lean/Init/Data/List/ToArray.olean", + "sha256": "d48db070507418071d7f3294285e8fd02ded1fe084445b6a728476fa0e5ef34b" + }, + "Init.Data.List.ToArrayImpl": { + "relative_path": "lib/lean/Init/Data/List/ToArrayImpl.olean", + "sha256": "877b70f91eb55124127734da7195914515b98abc3d601053119e4d10b3c749bf" + }, + "Init.Data.List.Zip": { + "relative_path": "lib/lean/Init/Data/List/Zip.olean", + "sha256": "b3ec8eed3d680c246fefdb0e57293acd2c2257a085937f2d1e026d118f6d3979" + }, + "Init.Data.Nat": { + "relative_path": "lib/lean/Init/Data/Nat.olean", + "sha256": "3447a7734bddbbc6904f5135e848dbca25c10bc5b6fad83b1beb09ac5bdb1fae" + }, + "Init.Data.Nat.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Basic.olean", + "sha256": "b2d11a9c4afa558c793fa12d41da087604ee0cf5dd8ee4f3c2f0b08e90031a50" + }, + "Init.Data.Nat.Bitwise": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise.olean", + "sha256": "ec84e12fb7c621de1fe2a6d0cf393bdec0b211e0741b6b343130d09417e0adc9" + }, + "Init.Data.Nat.Bitwise.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise/Basic.olean", + "sha256": "8f01e5e6af6b3366171fb8f21ba8a336c0ddef11a2a180b0fc033ef53757a69a" + }, + "Init.Data.Nat.Bitwise.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise/Lemmas.olean", + "sha256": "844179c496ff2ff5233abfec08e333e04170dd8b49a43f98ae15be7539b83b4b" + }, + "Init.Data.Nat.Compare": { + "relative_path": "lib/lean/Init/Data/Nat/Compare.olean", + "sha256": "9ce920efa06d6fb5e143925d07dd673e488640a5fc56c8c814ef41f383a0b6aa" + }, + "Init.Data.Nat.Control": { + "relative_path": "lib/lean/Init/Data/Nat/Control.olean", + "sha256": "126864791c444a3025fb8be008a42e792773f82535cb1fe9c80b6a9b0cbb0783" + }, + "Init.Data.Nat.Div.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Div/Basic.olean", + "sha256": "90ace86481881951b8aac0c78b829052894c5168bb81b4e32c48daefe634259e" + }, + "Init.Data.Nat.Div.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Div/Lemmas.olean", + "sha256": "06a8a626caa61480fa596adfa0fe6230b4b84cdbbf4f049da8a744dffa25efbc" + }, + "Init.Data.Nat.Dvd": { + "relative_path": "lib/lean/Init/Data/Nat/Dvd.olean", + "sha256": "36f58914fb3acef3f1b99aae4e1024647886c96f3575cd2cdb7b90e48b63a62f" + }, + "Init.Data.Nat.Fold": { + "relative_path": "lib/lean/Init/Data/Nat/Fold.olean", + "sha256": "ccbbc29df5d8b98e47f6d1ee36aa3cb036aa61c3adad7945bd72ef22117ecf0a" + }, + "Init.Data.Nat.Gcd": { + "relative_path": "lib/lean/Init/Data/Nat/Gcd.olean", + "sha256": "746fe45b4e8c648caebc10c1ba9e2736ebd492bb4854edc96c8d5c0f10905666" + }, + "Init.Data.Nat.Lcm": { + "relative_path": "lib/lean/Init/Data/Nat/Lcm.olean", + "sha256": "bbb02321b1e2b2422adf0d8c10b3800afe668a9edbb434e3dbd83c45386539de" + }, + "Init.Data.Nat.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Lemmas.olean", + "sha256": "7acb7e4f1b14d45188f28aa341f9013ee1c6bba8f0e1c2f3be74e04dd24b4782" + }, + "Init.Data.Nat.Linear": { + "relative_path": "lib/lean/Init/Data/Nat/Linear.olean", + "sha256": "33b034e32879e503ae843a62df9969d47e341eddf2650e299209e1494e507c2c" + }, + "Init.Data.Nat.Log2": { + "relative_path": "lib/lean/Init/Data/Nat/Log2.olean", + "sha256": "a1147619414a0561c2e404ca16b6f9c1b3e764fd66917d26964ff53d6f33d10b" + }, + "Init.Data.Nat.MinMax": { + "relative_path": "lib/lean/Init/Data/Nat/MinMax.olean", + "sha256": "813cd65d09f92a707754d8d86d35ae396b2ac77953076e7444021250799546dc" + }, + "Init.Data.Nat.Mod": { + "relative_path": "lib/lean/Init/Data/Nat/Mod.olean", + "sha256": "232fa20934aab58dfc025430ba91fe814d90e0e67f979a401fc91ea8a0fd06e3" + }, + "Init.Data.Nat.Power2": { + "relative_path": "lib/lean/Init/Data/Nat/Power2.olean", + "sha256": "aa68d47f1481ea940e4f2f3eeb5eb0cf44d9d36a81f02609f834bce92b36144a" + }, + "Init.Data.Nat.SOM": { + "relative_path": "lib/lean/Init/Data/Nat/SOM.olean", + "sha256": "be398ccbd96728c1500ab66aa2063131d37d6acd214067dbe14fb3a61150ff4d" + }, + "Init.Data.Nat.Simproc": { + "relative_path": "lib/lean/Init/Data/Nat/Simproc.olean", + "sha256": "491fdb35ea98fc6d352b6cb46c3681d42cb9e23f2df42a07a8e764b54ef7a62b" + }, + "Init.Data.NeZero": { + "relative_path": "lib/lean/Init/Data/NeZero.olean", + "sha256": "5fcec208f2769e4ec00ebf7dc0b534ffba76859d7390bac0ba36da69c8d06d0d" + }, + "Init.Data.OfScientific": { + "relative_path": "lib/lean/Init/Data/OfScientific.olean", + "sha256": "5a86fb094fc122609b959999bc53159282db03b2aba36b1d564270c95b630cc7" + }, + "Init.Data.Option": { + "relative_path": "lib/lean/Init/Data/Option.olean", + "sha256": "7cec7ba7cbb4f8c12b723822ef37fa80d7fe6dad55ffe781b04d480f37bee3e9" + }, + "Init.Data.Option.Attach": { + "relative_path": "lib/lean/Init/Data/Option/Attach.olean", + "sha256": "d13d8661e92455466e2652e81b0fc20660c6f68f61563e06ff9ada3b2adef85e" + }, + "Init.Data.Option.Basic": { + "relative_path": "lib/lean/Init/Data/Option/Basic.olean", + "sha256": "8a83ae7602811f2a8caa2f5ec890dfcaad71b7fee193f45329f23ce538838eae" + }, + "Init.Data.Option.BasicAux": { + "relative_path": "lib/lean/Init/Data/Option/BasicAux.olean", + "sha256": "69c9769a227956d0a18263f65759b2c78eeca5fc23df52fada29fae941be58b8" + }, + "Init.Data.Option.Instances": { + "relative_path": "lib/lean/Init/Data/Option/Instances.olean", + "sha256": "c2af58842fc1a5ace3156d8cc201a287eb79ad7707be50f11d43d9f6096452b8" + }, + "Init.Data.Option.Lemmas": { + "relative_path": "lib/lean/Init/Data/Option/Lemmas.olean", + "sha256": "832a8d1633685e7ace5ceb52ee44b1f441548ff85b6f15687314cc3709b9138e" + }, + "Init.Data.Option.List": { + "relative_path": "lib/lean/Init/Data/Option/List.olean", + "sha256": "919cbd303c6345f52d6c019146d46b4249daf12fe9fd3c2cfbece14797be8393" + }, + "Init.Data.Option.Monadic": { + "relative_path": "lib/lean/Init/Data/Option/Monadic.olean", + "sha256": "6f76327d567c5dbf041689c11ff396fdebbc832a1640d003ad2020671282aeb1" + }, + "Init.Data.Ord": { + "relative_path": "lib/lean/Init/Data/Ord.olean", + "sha256": "f9c47b462803dd4e251e3c89acc944998c255728461d0b038aa239e067c81a9c" + }, + "Init.Data.PLift": { + "relative_path": "lib/lean/Init/Data/PLift.olean", + "sha256": "2bed69175449aa3166dc103d9cf368e494b4d1752ed6e864250214256d710739" + }, + "Init.Data.Prod": { + "relative_path": "lib/lean/Init/Data/Prod.olean", + "sha256": "0498bf822d3922cd5bbc154bf0adef4fd76e4fe6a57f8e39fefa49ae9e16ca13" + }, + "Init.Data.Queue": { + "relative_path": "lib/lean/Init/Data/Queue.olean", + "sha256": "ab5118c07c9c0ed7d0819d19d442d1e6143f265f784f48151be1c4e2cd895606" + }, + "Init.Data.RArray": { + "relative_path": "lib/lean/Init/Data/RArray.olean", + "sha256": "9abe7370b3817a85b8512bc51dadc386f314bdcec188736b2f87405d5a9bb09b" + }, + "Init.Data.Random": { + "relative_path": "lib/lean/Init/Data/Random.olean", + "sha256": "5a34ed96d6a9814781db7e6c93847b8cd7caeb7071b2256058964866ec706af5" + }, + "Init.Data.Range": { + "relative_path": "lib/lean/Init/Data/Range.olean", + "sha256": "c64640dc9f5f61844778a90d7acc0f8f632ec11aa1746689c960d0f459bfaf46" + }, + "Init.Data.Range.Basic": { + "relative_path": "lib/lean/Init/Data/Range/Basic.olean", + "sha256": "bf692fd52dbffb6518f9a189179263fc4c49b436dbdb9eba2f00940de6665353" + }, + "Init.Data.Range.Lemmas": { + "relative_path": "lib/lean/Init/Data/Range/Lemmas.olean", + "sha256": "19e241eb048d7046e42e9117499d5bc8a43dddf66dacbb087966b4d16b82b06b" + }, + "Init.Data.Repr": { + "relative_path": "lib/lean/Init/Data/Repr.olean", + "sha256": "cbbd2014d6cee442d42c9c4d6997aa1e27dd3a4ea4fef43d1de4c1f184d02138" + }, + "Init.Data.SInt": { + "relative_path": "lib/lean/Init/Data/SInt.olean", + "sha256": "21f02e1e015c8ceee0e8afe9a24f8150714739a4df724b922e7b3f3756cc530d" + }, + "Init.Data.SInt.Basic": { + "relative_path": "lib/lean/Init/Data/SInt/Basic.olean", + "sha256": "c4b9b22f462ffe3dac0f5ce0d810e9cbbd3dda83a3c8f61aaca350f99edf30d9" + }, + "Init.Data.SInt.Bitwise": { + "relative_path": "lib/lean/Init/Data/SInt/Bitwise.olean", + "sha256": "784166152e7e37d32e49f556007eb9e8ac78a11e25a33159256124b1b6ac78b9" + }, + "Init.Data.SInt.Float": { + "relative_path": "lib/lean/Init/Data/SInt/Float.olean", + "sha256": "0fa2df58fc374f7d8f8381dc7369e0359fd56854418863015d82b50a49032bdd" + }, + "Init.Data.SInt.Float32": { + "relative_path": "lib/lean/Init/Data/SInt/Float32.olean", + "sha256": "08b0e06d73a8cc4989ef19e5b5dc0255aa458e852dade1660aeee88046199fb6" + }, + "Init.Data.SInt.Lemmas": { + "relative_path": "lib/lean/Init/Data/SInt/Lemmas.olean", + "sha256": "14f5714b32a97f7b89fe4f737e96d2d9576a75fdbdf62b848c26140b1be0d0b9" + }, + "Init.Data.Stream": { + "relative_path": "lib/lean/Init/Data/Stream.olean", + "sha256": "df7b2b39a4577fbe33f63d916ef4e0592fea0db8bc542b7e3f65bf8fca137950" + }, + "Init.Data.String": { + "relative_path": "lib/lean/Init/Data/String.olean", + "sha256": "44d46641afe72049132e8ba521b7e404190fb50b1710a008a531a6cb4bce4308" + }, + "Init.Data.String.Basic": { + "relative_path": "lib/lean/Init/Data/String/Basic.olean", + "sha256": "d7404ec9c0cedeb3e77cc7eadc3201e7cf1d44e1029407a279ce5dd2ab5537d1" + }, + "Init.Data.String.Extra": { + "relative_path": "lib/lean/Init/Data/String/Extra.olean", + "sha256": "5291234dedeae61b8f31129e9e8d90fcc2b91a784384250d36eea11c694e359a" + }, + "Init.Data.String.Lemmas": { + "relative_path": "lib/lean/Init/Data/String/Lemmas.olean", + "sha256": "e2fa260513d3ccaba3d0547bc5625ebbe09a171762e375b38b6dc1b8dc0fa6f5" + }, + "Init.Data.Subtype": { + "relative_path": "lib/lean/Init/Data/Subtype.olean", + "sha256": "1278a669b084dabde55a3f9a14c8b3ea7b7753b4b4d52bdbc1066bcb29f30208" + }, + "Init.Data.Sum": { + "relative_path": "lib/lean/Init/Data/Sum.olean", + "sha256": "0c08e5312a75c9474abf94ce7f6358efbdc6c178476005e36c22b5b294647930" + }, + "Init.Data.Sum.Basic": { + "relative_path": "lib/lean/Init/Data/Sum/Basic.olean", + "sha256": "30b5a85e6941f567feb412f1e6a4382d5c6d52558c4657285e80bd1b58879427" + }, + "Init.Data.Sum.Lemmas": { + "relative_path": "lib/lean/Init/Data/Sum/Lemmas.olean", + "sha256": "01ce321477e3f24f07aca5b0c4423c46d4c4e9533f25e00cdfd3f7e0af9ba319" + }, + "Init.Data.ToString": { + "relative_path": "lib/lean/Init/Data/ToString.olean", + "sha256": "bf141c2b4f750f8154aff447a05b8c02fc0231c48e550bf29823dd3a101b60a6" + }, + "Init.Data.ToString.Basic": { + "relative_path": "lib/lean/Init/Data/ToString/Basic.olean", + "sha256": "0892126af7fd71f9dd48a1f051af4f1ca5f181389a9b97dd7c759abcb8088fd0" + }, + "Init.Data.ToString.Macro": { + "relative_path": "lib/lean/Init/Data/ToString/Macro.olean", + "sha256": "3284b8ed0d3883ba46d39abb4d3620820bf6f12e47bfe3f33ead82ad80039580" + }, + "Init.Data.UInt": { + "relative_path": "lib/lean/Init/Data/UInt.olean", + "sha256": "a92781a10cb664f3b9dc344957d3c5c95bf9ec44fbe192cbb6ceac4c1d9f1391" + }, + "Init.Data.UInt.Basic": { + "relative_path": "lib/lean/Init/Data/UInt/Basic.olean", + "sha256": "d30c2c0bff573487362546d06fe7cf8fc0ae6dfead1379a1ad2523fc96795eb9" + }, + "Init.Data.UInt.BasicAux": { + "relative_path": "lib/lean/Init/Data/UInt/BasicAux.olean", + "sha256": "76e27df77fe31ef1d6b54d00a1758d579532a15787f4cfec7da774d535b47072" + }, + "Init.Data.UInt.Bitwise": { + "relative_path": "lib/lean/Init/Data/UInt/Bitwise.olean", + "sha256": "aa829cd7c8a6e68d0365d1662727646fc68b817428e469b33d96d057f6643d4e" + }, + "Init.Data.UInt.Lemmas": { + "relative_path": "lib/lean/Init/Data/UInt/Lemmas.olean", + "sha256": "5912f89a17ba6b111d9d7f3df46904b90811a4cdd80fc02a06984cd4c3dd3aa0" + }, + "Init.Data.UInt.Log2": { + "relative_path": "lib/lean/Init/Data/UInt/Log2.olean", + "sha256": "315c374ceeecdab0fde8042abffb68b082f063ce3ebf810efa46d89eb239faca" + }, + "Init.Data.ULift": { + "relative_path": "lib/lean/Init/Data/ULift.olean", + "sha256": "e1187f01e60437dc3c741cd1ba76657855642cc2574a59fa9a3be9a9e9d435b4" + }, + "Init.Data.Vector": { + "relative_path": "lib/lean/Init/Data/Vector.olean", + "sha256": "8ff79e5ffafceccc1bc38f3ac3d5ae7eb802c95cf1bd51393c6af7be6dfdea63" + }, + "Init.Data.Vector.Attach": { + "relative_path": "lib/lean/Init/Data/Vector/Attach.olean", + "sha256": "ecf089f945d2adcc57180f779593ccf0a2fa0c27d89968a7722b914f4b58b8af" + }, + "Init.Data.Vector.Basic": { + "relative_path": "lib/lean/Init/Data/Vector/Basic.olean", + "sha256": "afacc92812490337d7f03950905748563477bfe6494f046a0dfd9451aa4a4d65" + }, + "Init.Data.Vector.Count": { + "relative_path": "lib/lean/Init/Data/Vector/Count.olean", + "sha256": "b23fa70c6a9f0ea3b8ed1a4c811a2d0557751d4bb798e954d1ff985e00d492b1" + }, + "Init.Data.Vector.DecidableEq": { + "relative_path": "lib/lean/Init/Data/Vector/DecidableEq.olean", + "sha256": "4cf94f33d63c842c39f35392ce1bbf4c40ed1bfe9ec5161d522ba1442d8e0a2c" + }, + "Init.Data.Vector.Erase": { + "relative_path": "lib/lean/Init/Data/Vector/Erase.olean", + "sha256": "8c5cf30ba1225d74d85f93b3553f09e9299c182805f0efb44fad509ea5e56b78" + }, + "Init.Data.Vector.Extract": { + "relative_path": "lib/lean/Init/Data/Vector/Extract.olean", + "sha256": "0e12201859d76ac91415a74e00f909b32a631fefd2d2b5d7afeb0d2730bfa47a" + }, + "Init.Data.Vector.FinRange": { + "relative_path": "lib/lean/Init/Data/Vector/FinRange.olean", + "sha256": "b862166a52500e392a3cfab1b4b4f5d2b7b202725f48526a1e935ca52abdda38" + }, + "Init.Data.Vector.InsertIdx": { + "relative_path": "lib/lean/Init/Data/Vector/InsertIdx.olean", + "sha256": "c3f496caa69211325d18bc909f9be134bfd07515f8b95773b252004a71e01fc5" + }, + "Init.Data.Vector.Lemmas": { + "relative_path": "lib/lean/Init/Data/Vector/Lemmas.olean", + "sha256": "35726f2c825e29355e25d574a25470dba908ea9f680b92f4e6ab57ec77d47f3d" + }, + "Init.Data.Vector.Lex": { + "relative_path": "lib/lean/Init/Data/Vector/Lex.olean", + "sha256": "1541eb5302ac1fe618815bd36a3d4468f08003a6571118fc8322bbf155b441de" + }, + "Init.Data.Vector.MapIdx": { + "relative_path": "lib/lean/Init/Data/Vector/MapIdx.olean", + "sha256": "cbe812bbd7839fae0178d0c183d96d1f29f768b55349bebb47628f903c7cda57" + }, + "Init.Data.Vector.Monadic": { + "relative_path": "lib/lean/Init/Data/Vector/Monadic.olean", + "sha256": "c44bb39a17f785673f64d6e40116173d821d9184c41377371c5cb73565440a30" + }, + "Init.Data.Vector.OfFn": { + "relative_path": "lib/lean/Init/Data/Vector/OfFn.olean", + "sha256": "69f88342bdd241ebafeffb51ee94c1363ab096ea6d435ef4d062b1a552167cf4" + }, + "Init.Data.Vector.Range": { + "relative_path": "lib/lean/Init/Data/Vector/Range.olean", + "sha256": "88351024a2b10fd4648a0ae15e005d8799b95be7d0060c89a5a205a4fc40b56f" + }, + "Init.Data.Vector.Zip": { + "relative_path": "lib/lean/Init/Data/Vector/Zip.olean", + "sha256": "8c28067d8d5289ec3a5cbc9674643c688210c75813c69c0b66baba5ea29abaea" + }, + "Init.Data.Zero": { + "relative_path": "lib/lean/Init/Data/Zero.olean", + "sha256": "04d070309e7a1962ebcb5de2b2bfa69e5f5d4d54477689cbdbadb21202611dac" + }, + "Init.Dynamic": { + "relative_path": "lib/lean/Init/Dynamic.olean", + "sha256": "a9982d28dff48820a4e5310d473b53d19de91c1d1685749bccb849e881219fa1" + }, + "Init.Ext": { + "relative_path": "lib/lean/Init/Ext.olean", + "sha256": "1f32591106d111c224423e61d0afd89014b96aa77e9141c6bec47b33b80c31f7" + }, + "Init.GetElem": { + "relative_path": "lib/lean/Init/GetElem.olean", + "sha256": "2683b27cced90b5fbfbe5213c309ed94bf423edf90924a1002eea72b152fdb58" + }, + "Init.Grind": { + "relative_path": "lib/lean/Init/Grind.olean", + "sha256": "33eff60d5cea8bd5db12879a12cf1a1cf772b1a2ab778136cc138685bc23654a" + }, + "Init.Grind.Cases": { + "relative_path": "lib/lean/Init/Grind/Cases.olean", + "sha256": "d086d84578922287a95fedee2f43e884a629e838c2ff8e71efc2910510509594" + }, + "Init.Grind.Lemmas": { + "relative_path": "lib/lean/Init/Grind/Lemmas.olean", + "sha256": "ca22a5c6a54190290fc558e7805244c66c3c044c3a708a98300703d70bef11ec" + }, + "Init.Grind.Norm": { + "relative_path": "lib/lean/Init/Grind/Norm.olean", + "sha256": "3f889971f8415ffff0f737c2214d5be92be1294398624aec1c9d9bd45942dd66" + }, + "Init.Grind.Offset": { + "relative_path": "lib/lean/Init/Grind/Offset.olean", + "sha256": "4f95e7282b636fe3690d8b159425a37bf5bb2f80c49e7ccdd6170b6977148d50" + }, + "Init.Grind.PP": { + "relative_path": "lib/lean/Init/Grind/PP.olean", + "sha256": "d94c99691443ce7517096899dc89ffd3a1eff62b621e530ff98e46ff7a9e4407" + }, + "Init.Grind.Propagator": { + "relative_path": "lib/lean/Init/Grind/Propagator.olean", + "sha256": "e292ef4b9a9a4475f7c6eb767ddc84d8b5f0a30feabbbb1664966930e050496f" + }, + "Init.Grind.Tactics": { + "relative_path": "lib/lean/Init/Grind/Tactics.olean", + "sha256": "8c21109288355c0969f3fae78c66756b2a73699d4170d53336d0825a82b2b82d" + }, + "Init.Grind.Util": { + "relative_path": "lib/lean/Init/Grind/Util.olean", + "sha256": "666cf848a9a3ba30885be219a767d96bd2b6582fde19f84110c3c583308c5e8f" + }, + "Init.Guard": { + "relative_path": "lib/lean/Init/Guard.olean", + "sha256": "3bec2e0ab8c2829d1d13c64c80fb983b5d5f115a67b29ee64eedbe3f6628a470" + }, + "Init.Hints": { + "relative_path": "lib/lean/Init/Hints.olean", + "sha256": "5c814650ff2f23259cc67c04ab1a438222ec084d4369aca679fd0cc07cbb5474" + }, + "Init.Internal": { + "relative_path": "lib/lean/Init/Internal.olean", + "sha256": "2927550a155fb6115ac63e31cc35f9969047a6c015ced8325ce769d5631c0200" + }, + "Init.Internal.Order": { + "relative_path": "lib/lean/Init/Internal/Order.olean", + "sha256": "37884830614f3f48f325497beadc3cc60f0e363a1846cdcc28221ca05ba39759" + }, + "Init.Internal.Order.Basic": { + "relative_path": "lib/lean/Init/Internal/Order/Basic.olean", + "sha256": "c0b362116c8f553cc59964154fdc9a3418672bf9b5caee2b745608f40aa71091" + }, + "Init.Internal.Order.Lemmas": { + "relative_path": "lib/lean/Init/Internal/Order/Lemmas.olean", + "sha256": "198fb9d38168f2116937d641fa5419c99e0e9c03c0f630756f68affca451c1e0" + }, + "Init.Internal.Order.Tactic": { + "relative_path": "lib/lean/Init/Internal/Order/Tactic.olean", + "sha256": "d519c1d64b866e639de30ef452587bbe8802c64536e6ee541e47fcc7be3f942d" + }, + "Init.MacroTrace": { + "relative_path": "lib/lean/Init/MacroTrace.olean", + "sha256": "49d356d5728ea1a0ed6a14cbca10b6387f99d40b85602189566c4e4c1d6cc524" + }, + "Init.Meta": { + "relative_path": "lib/lean/Init/Meta.olean", + "sha256": "16b7ad338addb717e0eb584fc583a2e9d4e08242040654a2d3546650cb71bddc" + }, + "Init.MetaTypes": { + "relative_path": "lib/lean/Init/MetaTypes.olean", + "sha256": "1aa89a88743c9d8f66daecc6f28a7a7816efad55a42129bca1e2220450747bd8" + }, + "Init.Notation": { + "relative_path": "lib/lean/Init/Notation.olean", + "sha256": "576706b70dc9f21b093c7b10755e25c2f3fea8f04586b128893308730d715dae" + }, + "Init.NotationExtra": { + "relative_path": "lib/lean/Init/NotationExtra.olean", + "sha256": "92ba272c0a25c97e7800cdf2e948bb20e374861d28d31736d80a757b7dd852b0" + }, + "Init.Omega": { + "relative_path": "lib/lean/Init/Omega.olean", + "sha256": "ef46ae7141263a8f3168ddc0de5b10c37cd991f907e6558d6a10daed027950ad" + }, + "Init.Omega.Coeffs": { + "relative_path": "lib/lean/Init/Omega/Coeffs.olean", + "sha256": "a7f2688fb1799c93744fb62301026c37c58ee81d58eb91e80041622397bd1dd3" + }, + "Init.Omega.Constraint": { + "relative_path": "lib/lean/Init/Omega/Constraint.olean", + "sha256": "1e5a89907d661084e3223c006975f275efbe03df7c43fd18a68425798ac09189" + }, + "Init.Omega.Int": { + "relative_path": "lib/lean/Init/Omega/Int.olean", + "sha256": "335df595a7449bc9ab310b9a5914bcae3ad6219121cd1f67261deb8383b5d61d" + }, + "Init.Omega.IntList": { + "relative_path": "lib/lean/Init/Omega/IntList.olean", + "sha256": "315f3755c1bdb87eda3449e97cb3141b9bc69b88af3faa93b0c54a5bf16137bf" + }, + "Init.Omega.LinearCombo": { + "relative_path": "lib/lean/Init/Omega/LinearCombo.olean", + "sha256": "6f254b2ed1ea5d35519b633f58da229500dca18293b3d958c7f93cc6a7e64e67" + }, + "Init.Omega.Logic": { + "relative_path": "lib/lean/Init/Omega/Logic.olean", + "sha256": "c8b7e60bd2aeee6efbab4f4787a5eddcb8b6ccb02841b7948b5120b5dbc7f5be" + }, + "Init.Prelude": { + "relative_path": "lib/lean/Init/Prelude.olean", + "sha256": "db4e87c0006f1303f3d41ca9a615a4890ca94309812bda09476677ea9bb5d672" + }, + "Init.PropLemmas": { + "relative_path": "lib/lean/Init/PropLemmas.olean", + "sha256": "f95cab4646f43dbaca3fc915bbd32868f0ac73aaeba818d165843e276499542e" + }, + "Init.RCases": { + "relative_path": "lib/lean/Init/RCases.olean", + "sha256": "aa216281d8930fe16cdb7b6b1f604066e824b33eaf62870d41391040c2ba77b4" + }, + "Init.ShareCommon": { + "relative_path": "lib/lean/Init/ShareCommon.olean", + "sha256": "c2647e2778a9bf01ffdc302ea5604308036ee982de23feac85ce21805f0b3ba8" + }, + "Init.SimpLemmas": { + "relative_path": "lib/lean/Init/SimpLemmas.olean", + "sha256": "37b58f69317f08a8e55d1f3950c4d00ccb29ebed135eb5e9789e8feb4f412369" + }, + "Init.Simproc": { + "relative_path": "lib/lean/Init/Simproc.olean", + "sha256": "53b36872b429c61141ac340011f233e680f82ccced2fb43fabf9fbeca5807040" + }, + "Init.SizeOf": { + "relative_path": "lib/lean/Init/SizeOf.olean", + "sha256": "0b2e2a18d9b699a5236c79acca835fd68f5400bbd998ca5743825c5734b6d589" + }, + "Init.SizeOfLemmas": { + "relative_path": "lib/lean/Init/SizeOfLemmas.olean", + "sha256": "ef5ba22b92506575f987eaea9cb87eda5a1d870da071e53f1257cb1cc999fd85" + }, + "Init.Syntax": { + "relative_path": "lib/lean/Init/Syntax.olean", + "sha256": "55eab3582563a12c40c7797ed6d06db613c855508c3138df975d2613422f6399" + }, + "Init.System": { + "relative_path": "lib/lean/Init/System.olean", + "sha256": "7a0e2f92d28211ac4da2835c7b15db71b08799d68e0c759c0f899b7c19ef564c" + }, + "Init.System.FilePath": { + "relative_path": "lib/lean/Init/System/FilePath.olean", + "sha256": "cdc4f4ecf0cd8470047e8c1e706d22f7321bee3072e44a669481e56689e187f1" + }, + "Init.System.IO": { + "relative_path": "lib/lean/Init/System/IO.olean", + "sha256": "069217c5d17f79433867ec6f701a5702cb40c88485dedc61be1f1ce0ef9b44fb" + }, + "Init.System.IOError": { + "relative_path": "lib/lean/Init/System/IOError.olean", + "sha256": "6e1ff344b12e6d7fcbb7abea99eaa3c88ae2626dd669d7f3c545822f96494ec2" + }, + "Init.System.Mutex": { + "relative_path": "lib/lean/Init/System/Mutex.olean", + "sha256": "fc950b4b00a1c3104ea945a9a93ab51807521b29a0b83518127de77eb3f76922" + }, + "Init.System.Platform": { + "relative_path": "lib/lean/Init/System/Platform.olean", + "sha256": "b679564c6df441632b6277f089cd588220ae5c4b8ae519873dc3172bb3091e52" + }, + "Init.System.Promise": { + "relative_path": "lib/lean/Init/System/Promise.olean", + "sha256": "78dc6c800d0f873e6520dbcf32c9dda22370563c75f086fb03e25fae393e848c" + }, + "Init.System.ST": { + "relative_path": "lib/lean/Init/System/ST.olean", + "sha256": "3fc620f17a5cb9e2243d760ffcb7ede9227b8c639c9376ff25c6bea1a7c1a7e7" + }, + "Init.System.Uri": { + "relative_path": "lib/lean/Init/System/Uri.olean", + "sha256": "d1a020ceeb21e6358fb0768345f90866752ef2dfe6c9dec71f388bd34b919de3" + }, + "Init.Tactics": { + "relative_path": "lib/lean/Init/Tactics.olean", + "sha256": "285e86e84ef77045b1f4944cacef6f11bca49334671808adec30f2e6fafd0dd8" + }, + "Init.TacticsExtra": { + "relative_path": "lib/lean/Init/TacticsExtra.olean", + "sha256": "e0521889dab4e1a74e8a407a0a0409109723ab9363b4be234115dc80aa01b5ba" + }, + "Init.Task": { + "relative_path": "lib/lean/Init/Task.olean", + "sha256": "effc51f55f006a6e54f0bb4b6577f7fe6a92d79958a0f3dfd258e4c53b9fa3c8" + }, + "Init.Try": { + "relative_path": "lib/lean/Init/Try.olean", + "sha256": "d289104c53a554fd4e7d8b81d5fd8212dcca854e6dec5cf80e088e3545a23c6b" + }, + "Init.Util": { + "relative_path": "lib/lean/Init/Util.olean", + "sha256": "da825c487c1ff3bf957f8ef84fade6ca10e2428807f84f52613551e11a404f03" + }, + "Init.WF": { + "relative_path": "lib/lean/Init/WF.olean", + "sha256": "16d58f1a3442679940e0f5d0eb9fd209e6eae04f7f4550dd7361847f0ba97082" + }, + "Init.WFTactics": { + "relative_path": "lib/lean/Init/WFTactics.olean", + "sha256": "edeb5134b3fc1f3234ef027a4d803b733c75a7174ac2a4bfe8a6353f783deb32" + }, + "Init.While": { + "relative_path": "lib/lean/Init/While.olean", + "sha256": "6fc8fbe7c581376a6826126ce6aacb031231cdc32afb135dfa3bfda884305625" + }, + "Lean": { + "relative_path": "lib/lean/Lean.olean", + "sha256": "7b09317fc9d21262dbfbb6f014dc40c2809b55e6cbb4f7587211a57ec91f7221" + }, + "Lean.AddDecl": { + "relative_path": "lib/lean/Lean/AddDecl.olean", + "sha256": "ec30e087524b32520021eeb3dc8c2d0aefdce838f11dd8e57f13cf1f05611cf8" + }, + "Lean.Attributes": { + "relative_path": "lib/lean/Lean/Attributes.olean", + "sha256": "e4db4a704b0260d6e36f4f542416091124e09767dc8bc759d2b1adbe53e9c166" + }, + "Lean.AuxRecursor": { + "relative_path": "lib/lean/Lean/AuxRecursor.olean", + "sha256": "8ad6ecf040763b62561819bb75de71763765566d01e68d3ed60fe27ff1b70b92" + }, + "Lean.BuiltinDocAttr": { + "relative_path": "lib/lean/Lean/BuiltinDocAttr.olean", + "sha256": "c9fb01241ff340cc8cdba6efffa553449f24748d42f0966903ce7b3038a6f266" + }, + "Lean.Class": { + "relative_path": "lib/lean/Lean/Class.olean", + "sha256": "0a41587a7d43178adb832ac6a835a3ded745f5b94f031b8a7fa916a6de2d681c" + }, + "Lean.Compiler": { + "relative_path": "lib/lean/Lean/Compiler.olean", + "sha256": "60a1e6cb63d9ee93f449d816b9d5f35d550da07c2ed98d4574cc00610aaa1fcc" + }, + "Lean.Compiler.AtMostOnce": { + "relative_path": "lib/lean/Lean/Compiler/AtMostOnce.olean", + "sha256": "46d86c6dc85f433a42dfa3a3162ed82530e0efd6d0def6857c447342776280b5" + }, + "Lean.Compiler.BorrowedAnnotation": { + "relative_path": "lib/lean/Lean/Compiler/BorrowedAnnotation.olean", + "sha256": "dfd99a6b65e28ce3c81d6effb32273e088fcce5829cbaeec57a98a4f325c70a8" + }, + "Lean.Compiler.CSimpAttr": { + "relative_path": "lib/lean/Lean/Compiler/CSimpAttr.olean", + "sha256": "4228ef18768f8fd70d1c48c5a5e9c7e0736e84389e0cc291d45ea6ef55853c85" + }, + "Lean.Compiler.ClosedTermCache": { + "relative_path": "lib/lean/Lean/Compiler/ClosedTermCache.olean", + "sha256": "332d9fcc102a8ec05d9d450f835de662c8b153274e86f4e8f8bf72bb7c0c86fa" + }, + "Lean.Compiler.ConstFolding": { + "relative_path": "lib/lean/Lean/Compiler/ConstFolding.olean", + "sha256": "a0f0396a65891075ef27848bf3578a2b14c5d9fa295ee982014d97cae25ec46c" + }, + "Lean.Compiler.ExportAttr": { + "relative_path": "lib/lean/Lean/Compiler/ExportAttr.olean", + "sha256": "f0975b5550d69d83ad3b27d0ad2363641167e47178788f22890be83d3e5511e6" + }, + "Lean.Compiler.ExternAttr": { + "relative_path": "lib/lean/Lean/Compiler/ExternAttr.olean", + "sha256": "c015f64d0e192ec7b6774ea02f82e8d210aa29022cc9317ba1f44f4d1db03983" + }, + "Lean.Compiler.FFI": { + "relative_path": "lib/lean/Lean/Compiler/FFI.olean", + "sha256": "5c592270389ca3547b225d542569d17074a72aab1d3069972aa13183c9defb4b" + }, + "Lean.Compiler.IR": { + "relative_path": "lib/lean/Lean/Compiler/IR.olean", + "sha256": "c0d443734bf92a204df7d44fb5b213073d860465d1940beb4f56be04fe95fa5d" + }, + "Lean.Compiler.IR.Basic": { + "relative_path": "lib/lean/Lean/Compiler/IR/Basic.olean", + "sha256": "256c663d51575e663739cf47717d5b563d91bccd233443d8c71ff95eb81ccf2b" + }, + "Lean.Compiler.IR.Borrow": { + "relative_path": "lib/lean/Lean/Compiler/IR/Borrow.olean", + "sha256": "76ccf72d60d34df08de11583942e4978c88f79daea6c48a34aee9b0b0164a143" + }, + "Lean.Compiler.IR.Boxing": { + "relative_path": "lib/lean/Lean/Compiler/IR/Boxing.olean", + "sha256": "ba56d60339b940f7b1d5f1bc244145dd90c835bd7a7c22501af7ab4eb502c7e9" + }, + "Lean.Compiler.IR.Checker": { + "relative_path": "lib/lean/Lean/Compiler/IR/Checker.olean", + "sha256": "0760b0f827e3f94462f855b0cde1e99a4f2ececa4dc914bb36ccc7388d05ea1f" + }, + "Lean.Compiler.IR.CompilerM": { + "relative_path": "lib/lean/Lean/Compiler/IR/CompilerM.olean", + "sha256": "3c51c9bc8b5684d2b997424a46ecfffd0faebaeccc20871faa6142bbdee6261e" + }, + "Lean.Compiler.IR.CtorLayout": { + "relative_path": "lib/lean/Lean/Compiler/IR/CtorLayout.olean", + "sha256": "41b6538779aec55878034a4311f5ec5afb609ee355306207f63d480beec7d8f1" + }, + "Lean.Compiler.IR.ElimDeadBranches": { + "relative_path": "lib/lean/Lean/Compiler/IR/ElimDeadBranches.olean", + "sha256": "db8b2361ec98aeab4251a3f24b6bdd6dfea6560736a7e2db580ac80ea5a19088" + }, + "Lean.Compiler.IR.ElimDeadVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/ElimDeadVars.olean", + "sha256": "fa545c9536767b2921812ec4f12787dbafdb12fba219c37c50ef08406aed35c0" + }, + "Lean.Compiler.IR.EmitC": { + "relative_path": "lib/lean/Lean/Compiler/IR/EmitC.olean", + "sha256": "8d3cc7f7314b0540efc952a891d2c04b146a0e974c78698f257aa84218e22fa8" + }, + "Lean.Compiler.IR.EmitUtil": { + "relative_path": "lib/lean/Lean/Compiler/IR/EmitUtil.olean", + "sha256": "d94b654927d21d70638e7be9f071d042f1ddef03ffb35c8e1873ce06f6bc0bec" + }, + "Lean.Compiler.IR.ExpandResetReuse": { + "relative_path": "lib/lean/Lean/Compiler/IR/ExpandResetReuse.olean", + "sha256": "52056b452d80b3cc358d961c340c878bd8fd439c4157f19579ab24b6e45beb63" + }, + "Lean.Compiler.IR.Format": { + "relative_path": "lib/lean/Lean/Compiler/IR/Format.olean", + "sha256": "7ce035303406e57cca579f9730815aae11392a6b068ebfb1ae5563989ef9d648" + }, + "Lean.Compiler.IR.FreeVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/FreeVars.olean", + "sha256": "b7689c40b2b8acb573130f0678e945f7de1f93cc0d2cc516992b735d3b16600c" + }, + "Lean.Compiler.IR.LiveVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/LiveVars.olean", + "sha256": "04dffa3befd0baf2b1caabada126812e8799e0842e88ae55d2f9f435b210bba7" + }, + "Lean.Compiler.IR.NormIds": { + "relative_path": "lib/lean/Lean/Compiler/IR/NormIds.olean", + "sha256": "42d1c0c091dd6795dc22f817e1bbd69f8a023744028d476ee73c3d47b9094507" + }, + "Lean.Compiler.IR.PushProj": { + "relative_path": "lib/lean/Lean/Compiler/IR/PushProj.olean", + "sha256": "45d3a0ef752e7ec5a2868af25c01793a0e9763307b35d8821fb1aeeb0886e5e7" + }, + "Lean.Compiler.IR.RC": { + "relative_path": "lib/lean/Lean/Compiler/IR/RC.olean", + "sha256": "efe9f4218bc3bc9ff1df43dbd6d5d5629c6914bc69834a1642f67aa16b9c7a1c" + }, + "Lean.Compiler.IR.ResetReuse": { + "relative_path": "lib/lean/Lean/Compiler/IR/ResetReuse.olean", + "sha256": "efe1a6814901274604fe1e6ada5e6819c56a50ade0732c255a5fabbac86b90f0" + }, + "Lean.Compiler.IR.SimpCase": { + "relative_path": "lib/lean/Lean/Compiler/IR/SimpCase.olean", + "sha256": "3c29f2a2fc5a04a44b6afa8c945055dc63aaee07fa17412c49f32b66b93af17b" + }, + "Lean.Compiler.IR.Sorry": { + "relative_path": "lib/lean/Lean/Compiler/IR/Sorry.olean", + "sha256": "4f931aed57566e1db5097e0703d072434871fcfad52bedd7afefda28c9e28b49" + }, + "Lean.Compiler.IR.UnboxResult": { + "relative_path": "lib/lean/Lean/Compiler/IR/UnboxResult.olean", + "sha256": "7a27c69a4b077ee78cd5c060dab56b7af05e02428073627d28ccdff330e74670" + }, + "Lean.Compiler.ImplementedByAttr": { + "relative_path": "lib/lean/Lean/Compiler/ImplementedByAttr.olean", + "sha256": "0bdd1c11d87a3e766eb8372e72dbdc72606b0367551455d1ff3093d50a14ba0e" + }, + "Lean.Compiler.InitAttr": { + "relative_path": "lib/lean/Lean/Compiler/InitAttr.olean", + "sha256": "a4b773a972dd41b77fa8973f7c570e3c2f1eef2a56e36c6b5b91a9543fe23efd" + }, + "Lean.Compiler.InlineAttrs": { + "relative_path": "lib/lean/Lean/Compiler/InlineAttrs.olean", + "sha256": "1dc521edbac6c28fb0abe0b1bfa72372d225b00d184228cb135fea3b3900583c" + }, + "Lean.Compiler.LCNF": { + "relative_path": "lib/lean/Lean/Compiler/LCNF.olean", + "sha256": "50ba85811e79db199dcc8528997fe62c599b3e36bae0bff0c56da744a975815e" + }, + "Lean.Compiler.LCNF.AlphaEqv": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/AlphaEqv.olean", + "sha256": "3e525daf1858d10b3c576598392a797f9bc77af47c88877a81f4b80f95e39f60" + }, + "Lean.Compiler.LCNF.AuxDeclCache": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/AuxDeclCache.olean", + "sha256": "e4ebfeac04cc04ab322e324c6b5cceb5fb0049899d323ace2185ed1d82f20460" + }, + "Lean.Compiler.LCNF.BaseTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/BaseTypes.olean", + "sha256": "5053822e35b6065475c75ea4121fb7c0e5572473b589a6318c23d8245cb91031" + }, + "Lean.Compiler.LCNF.Basic": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Basic.olean", + "sha256": "61a9c336f3fc892426f33ce054488c33e6c853038561acc10f6e68f1c4dae86f" + }, + "Lean.Compiler.LCNF.Bind": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Bind.olean", + "sha256": "ddcb0976ae13b967a67b86197dd84df7911382cfc311cc72f1643bcde382170e" + }, + "Lean.Compiler.LCNF.CSE": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CSE.olean", + "sha256": "0f30cf963d74e913c63d6a61eb2e6024a51aae3598e1bb7d67fe68e2571983b1" + }, + "Lean.Compiler.LCNF.Check": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Check.olean", + "sha256": "bfa8071c59de426aaa04e96c0c7cc9adabcba58266af88e878efc333efa217cc" + }, + "Lean.Compiler.LCNF.Closure": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Closure.olean", + "sha256": "8e07eaf84941feda5b4549dcbbfa53cd0981cf41053d3cb7604de6b37055b89c" + }, + "Lean.Compiler.LCNF.CompatibleTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CompatibleTypes.olean", + "sha256": "bbbd5d8598de30d40edc079da53afced3be253be5f5bc1ba5098b673a39178a7" + }, + "Lean.Compiler.LCNF.CompilerM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CompilerM.olean", + "sha256": "0dba55f8281250c8f7c8ca16d327e9c699a12bc22b7a740cc4494c9807071148" + }, + "Lean.Compiler.LCNF.ConfigOptions": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ConfigOptions.olean", + "sha256": "911b57609345802250709851c15ca20bb8b0c72d7cd38eb43691c09523cec4a7" + }, + "Lean.Compiler.LCNF.DeclHash": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/DeclHash.olean", + "sha256": "5e269b1f1ac7904fb9ebb77fe9805065fbb378fecf06eef5f123dc27a84b8555" + }, + "Lean.Compiler.LCNF.DependsOn": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/DependsOn.olean", + "sha256": "e7d096fac73063f27b1fc6f49c0eb5c4b7edb7075115cae9f2635e894fc7b070" + }, + "Lean.Compiler.LCNF.ElimDead": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ElimDead.olean", + "sha256": "477333313db8979680b9ee364d3075b5162225b83a69c60f18afca99f5f184c9" + }, + "Lean.Compiler.LCNF.ElimDeadBranches": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ElimDeadBranches.olean", + "sha256": "67ca5f89e780bfa7c0e62c0318b038421385dd3d9165ee207e2ba55a8edc3b50" + }, + "Lean.Compiler.LCNF.FVarUtil": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FVarUtil.olean", + "sha256": "d15ee92fbc441d2a5805f9fd5f851c49dd7267fc259d058273771168ce44b2b4" + }, + "Lean.Compiler.LCNF.FixedParams": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FixedParams.olean", + "sha256": "02e113791b21bc00471cc5e650e0167187e9b60993dc1627c1a0591cf9e928dc" + }, + "Lean.Compiler.LCNF.FloatLetIn": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FloatLetIn.olean", + "sha256": "aa1a425efb344b0216c4d87f584165e314acc54702788de99d359010f51cd5ef" + }, + "Lean.Compiler.LCNF.InferType": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/InferType.olean", + "sha256": "b91d6fbb425074a2e8296fbc557159c22b409e8f2ffa2dcf554f17d8d40f43fc" + }, + "Lean.Compiler.LCNF.Internalize": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Internalize.olean", + "sha256": "ddf26e1a280b6fcf208f46ca6683ffe8ef366527c447557a8852ba581abab6ff" + }, + "Lean.Compiler.LCNF.JoinPoints": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/JoinPoints.olean", + "sha256": "7955fd7fbf4caccbfc179059f5821358b5155dcce356bf20dbc5465989d12831" + }, + "Lean.Compiler.LCNF.LCtx": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/LCtx.olean", + "sha256": "798958fc2fdf1ff92063e6a5696a66dd32273a5eb6e04bfb217759105882742a" + }, + "Lean.Compiler.LCNF.LambdaLifting": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/LambdaLifting.olean", + "sha256": "16f7b519cd8548d6a88aff2c02029440110f13b2b009fb26afa4e8018d76f106" + }, + "Lean.Compiler.LCNF.Level": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Level.olean", + "sha256": "0ff39a4eec80e3c8047e926f4843c44eea5c1516e24c059c1c941d0948df7a6b" + }, + "Lean.Compiler.LCNF.Main": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Main.olean", + "sha256": "3678ef37331fb5a8b609a8ebfae188c589e87fef79ffff24533ea4059160f40c" + }, + "Lean.Compiler.LCNF.MonadScope": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/MonadScope.olean", + "sha256": "b16649d04910e51525f2513891c35417ccc791a9d19331355aea31cdbbe72a2e" + }, + "Lean.Compiler.LCNF.MonoTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/MonoTypes.olean", + "sha256": "6135eec86d64970beb3d9b00a2b74b30c0401784884cde565eefe186f42c7dac" + }, + "Lean.Compiler.LCNF.OtherDecl": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/OtherDecl.olean", + "sha256": "3cd7c6d125c8127901949761c55b36ebc963b7f28047fbb67221f978b966d0d0" + }, + "Lean.Compiler.LCNF.PassManager": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PassManager.olean", + "sha256": "0e7573909dd4940a95abface78fa3660072b1c6163a859562aec0e48c85451cf" + }, + "Lean.Compiler.LCNF.Passes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Passes.olean", + "sha256": "4b8864ccdfb3dabe28940e0e21f1726c3bbb252371c38e7992852f7da95ad0c9" + }, + "Lean.Compiler.LCNF.PhaseExt": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PhaseExt.olean", + "sha256": "8ed93f368be15928b930d48136cac9cac5eb283d269b53a4ccf9dc915480564c" + }, + "Lean.Compiler.LCNF.PrettyPrinter": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PrettyPrinter.olean", + "sha256": "484d0ba585c4943205d33a53df8d4735f52e7b4c65f9cc39a2dadece7e3ee769" + }, + "Lean.Compiler.LCNF.PullFunDecls": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PullFunDecls.olean", + "sha256": "20c18b55f55cc4cf61b95e3be8c6e2c2c1ce63af493e30d543534faf53550bc7" + }, + "Lean.Compiler.LCNF.PullLetDecls": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PullLetDecls.olean", + "sha256": "848f051bce9b922816355c97fc84232a03f85ed5fa38feed1b12ec6ff07eacac" + }, + "Lean.Compiler.LCNF.ReduceArity": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ReduceArity.olean", + "sha256": "bfb8fba4b4cf6829d092a9f3f4b5807108f7110296e6a9f71ceeb1f6ec90cd43" + }, + "Lean.Compiler.LCNF.ReduceJpArity": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ReduceJpArity.olean", + "sha256": "9bb32eeb3214ac55e1013ad425fd0c6852607391296751fddc2b8f4553f68c3e" + }, + "Lean.Compiler.LCNF.Renaming": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Renaming.olean", + "sha256": "bddac036add967291692acef307d3315af8aed4fd89a18d34311ac694ecf7816" + }, + "Lean.Compiler.LCNF.ScopeM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ScopeM.olean", + "sha256": "28822aa06f00730aba221eb7ae6cb264bb494bf25280246ffe6ff36c76243d28" + }, + "Lean.Compiler.LCNF.Simp": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp.olean", + "sha256": "58be16412a7c090265590410396a8263ede4d980f046637dff96f4a94d5d0b43" + }, + "Lean.Compiler.LCNF.Simp.Basic": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Basic.olean", + "sha256": "0bef1c90ca8bed6f80869aeb298d70671f82c7eec6f32e4576cca8d078d2ddfd" + }, + "Lean.Compiler.LCNF.Simp.Config": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Config.olean", + "sha256": "df3ec1bf55fe323c59d24d9e289dbb55b8e4e153686895cb4c6efbf33e693392" + }, + "Lean.Compiler.LCNF.Simp.ConstantFold": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/ConstantFold.olean", + "sha256": "63f240d9e408f7f34c53731a4b40b6784f639f7df3a130297aa52df6c5868ca3" + }, + "Lean.Compiler.LCNF.Simp.DefaultAlt": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.olean", + "sha256": "c7e68d37f1843b498489140e970e2caaa36548918cae5ddd881236065fdf9dfa" + }, + "Lean.Compiler.LCNF.Simp.DiscrM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/DiscrM.olean", + "sha256": "484a04366395e90ad0b5dd5c692a9e0da30c0918f50cca2ce7dc4459fbd6a590" + }, + "Lean.Compiler.LCNF.Simp.FunDeclInfo": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.olean", + "sha256": "63a8525abb01ee09dcd5fd7bb66fd5d5c9139ec98c9c4622594f19d042b7a81d" + }, + "Lean.Compiler.LCNF.Simp.InlineCandidate": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.olean", + "sha256": "04353a98d60a93bb13f644bc92b81233d665eff28f5e2594d7b7a45ef883572c" + }, + "Lean.Compiler.LCNF.Simp.InlineProj": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineProj.olean", + "sha256": "949390558396b4e92eb72823f8f123ce6a6a310b8e77234bd741d36a8158c1a4" + }, + "Lean.Compiler.LCNF.Simp.JpCases": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/JpCases.olean", + "sha256": "88b4036ff347ff9a1678d5eb585ca362ae0090e9de2b646e2efe90f4dc9a2328" + }, + "Lean.Compiler.LCNF.Simp.Main": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Main.olean", + "sha256": "0ae14b3273b7cb404efb46440a25ac0aaf8e49cd31eb57bea19b7833c219365b" + }, + "Lean.Compiler.LCNF.Simp.SimpM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpM.olean", + "sha256": "df1538b785d0aaa55d1d73ab4b63fd693959896c231a826d39818bddcb6b0d08" + }, + "Lean.Compiler.LCNF.Simp.SimpValue": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpValue.olean", + "sha256": "5de57ce90ffa7ba15734b33a8ad519ee98115c1e83f7ce047fcad5eb03bbe297" + }, + "Lean.Compiler.LCNF.Simp.Used": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Used.olean", + "sha256": "a4983d2052c84460309e9808f3d4518e65f78d7097eb707772abe71ba2bf5e4c" + }, + "Lean.Compiler.LCNF.SpecInfo": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/SpecInfo.olean", + "sha256": "4d9ce851163d5921bf6573eaf6b3d68442709f279fa96b23336b7b32d58a440b" + }, + "Lean.Compiler.LCNF.Specialize": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Specialize.olean", + "sha256": "9ecbcb6a200ec1984ed5231ba427a912a51177fbbfcf2d7ae584aba44397758b" + }, + "Lean.Compiler.LCNF.Testing": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Testing.olean", + "sha256": "8f082e72af8eb9e42eda181444b84c6a71e1a38e65b92e335abe9fda5f77d9cd" + }, + "Lean.Compiler.LCNF.ToDecl": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToDecl.olean", + "sha256": "edd9baf0d9dcc767a237f6ab3d3b8be89f5f7a8486579a61d92f3ee55c85ec8b" + }, + "Lean.Compiler.LCNF.ToExpr": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToExpr.olean", + "sha256": "97eb45572133529cfcd4d6581a8a27c406477191a1b027b7dbc8bbaf45bab62d" + }, + "Lean.Compiler.LCNF.ToLCNF": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToLCNF.olean", + "sha256": "3d2ca7cd028efcacaa2882570d10dd518c5a73860de6ceebb68658b3439607ab" + }, + "Lean.Compiler.LCNF.ToMono": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToMono.olean", + "sha256": "9c42901d6b7192fd65b8a5f809566805abc90063211569894835a17be53820b3" + }, + "Lean.Compiler.LCNF.Types": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Types.olean", + "sha256": "19db15eb19ec6842ff578614e85a7323642539fbb955b5912c170dec0eae2292" + }, + "Lean.Compiler.LCNF.Util": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Util.olean", + "sha256": "2a73fb99a3cb08e8a41425bc5ca182aaaa401508e583d6305a70868ea56208c3" + }, + "Lean.Compiler.Main": { + "relative_path": "lib/lean/Lean/Compiler/Main.olean", + "sha256": "9dc59f3522ff5c16389fc3454829050f7613c2f4175037beab5c0e4f86468de3" + }, + "Lean.Compiler.NameMangling": { + "relative_path": "lib/lean/Lean/Compiler/NameMangling.olean", + "sha256": "52aa954ea4c255de3c15968d309de875c4b03892e28568614f5b9e5d6bc3f38c" + }, + "Lean.Compiler.NeverExtractAttr": { + "relative_path": "lib/lean/Lean/Compiler/NeverExtractAttr.olean", + "sha256": "8efc3ead298e537a086cd425cfd99e6cd10185c78b13d8654d04435ed0f2c577" + }, + "Lean.Compiler.NoncomputableAttr": { + "relative_path": "lib/lean/Lean/Compiler/NoncomputableAttr.olean", + "sha256": "e396574927b99c247f101c8248a0a09cdff7a46e3809fb4589f0dcc4fba6d106" + }, + "Lean.Compiler.Old": { + "relative_path": "lib/lean/Lean/Compiler/Old.olean", + "sha256": "abc232855b58731d54ab07783fa46843208c6deace78b6b370cf476353c3e46d" + }, + "Lean.Compiler.Options": { + "relative_path": "lib/lean/Lean/Compiler/Options.olean", + "sha256": "b86376be11dc414b13c5a54d25cb7817f5660a01981e99d7f45f587f9a2933df" + }, + "Lean.Compiler.Specialize": { + "relative_path": "lib/lean/Lean/Compiler/Specialize.olean", + "sha256": "401294d22aa31d66ffea73cc8e81b84069c82bbf437abe562251e13bfd93394a" + }, + "Lean.CoreM": { + "relative_path": "lib/lean/Lean/CoreM.olean", + "sha256": "5e46337730d7e521a4ee2760c1adaea3e2862c5cc8006afed50f290ca2aafea7" + }, + "Lean.Data": { + "relative_path": "lib/lean/Lean/Data.olean", + "sha256": "3ea6fcf75dec1adae7990d5823a1527d3306689cb440e3c5ecea7b7ea7aab07d" + }, + "Lean.Data.Array": { + "relative_path": "lib/lean/Lean/Data/Array.olean", + "sha256": "d21870a1441bb3b382f82f64457d1fabeb8ab046e4147892433f89143f8481ea" + }, + "Lean.Data.AssocList": { + "relative_path": "lib/lean/Lean/Data/AssocList.olean", + "sha256": "9a08b7424a24c46dd2284b4c7b8692181a5e608302ae500e6445d627ea448d41" + }, + "Lean.Data.DeclarationRange": { + "relative_path": "lib/lean/Lean/Data/DeclarationRange.olean", + "sha256": "0c7a925cebc8a6c0405a7f6741afe5ecebca751b7141fc36518c902615167d6d" + }, + "Lean.Data.Format": { + "relative_path": "lib/lean/Lean/Data/Format.olean", + "sha256": "64c298e5e84c96a54830f2e1cf59e23ecd5c91c45336d9e99aa368884d8a9069" + }, + "Lean.Data.FuzzyMatching": { + "relative_path": "lib/lean/Lean/Data/FuzzyMatching.olean", + "sha256": "558ddc6d5ca38eada259e0fa5ad47478d15ba0f7878a7becb1c04394e7e98b19" + }, + "Lean.Data.Json": { + "relative_path": "lib/lean/Lean/Data/Json.olean", + "sha256": "3839c3f8868485cc28a91248414f8d7b15e3785cadd116d77d254f3acef1b768" + }, + "Lean.Data.Json.Basic": { + "relative_path": "lib/lean/Lean/Data/Json/Basic.olean", + "sha256": "d4a1599c4250412e05b960339e4898b1b5a9dde3f0292029eb02947f7df091cb" + }, + "Lean.Data.Json.Elab": { + "relative_path": "lib/lean/Lean/Data/Json/Elab.olean", + "sha256": "75bd0e3c0b0e50b6890616aff9499849bcc80f783737fb06762b1e638ce6641a" + }, + "Lean.Data.Json.FromToJson": { + "relative_path": "lib/lean/Lean/Data/Json/FromToJson.olean", + "sha256": "bc5266fe22b0d8289fac5e2194f2f3a5c0efa79dc538a96dee258041d8296066" + }, + "Lean.Data.Json.Parser": { + "relative_path": "lib/lean/Lean/Data/Json/Parser.olean", + "sha256": "eb9a4c2f421543848f9e21ff12b4cbf7ec42e0b339c4cc81725e9be627307a46" + }, + "Lean.Data.Json.Printer": { + "relative_path": "lib/lean/Lean/Data/Json/Printer.olean", + "sha256": "18bc6d83251888a60b8e091d5a7cd832d1733cca7cf8fc0afd197db2cd4bac6d" + }, + "Lean.Data.Json.Stream": { + "relative_path": "lib/lean/Lean/Data/Json/Stream.olean", + "sha256": "bbb7aea03b82669971dae676811dc7c4d2f91530d1b95dec8186faad10a2690e" + }, + "Lean.Data.JsonRpc": { + "relative_path": "lib/lean/Lean/Data/JsonRpc.olean", + "sha256": "324ae0dd9b94d607f0bd3634ff28ee91747e533225a1787ccffd3cdff6e78934" + }, + "Lean.Data.KVMap": { + "relative_path": "lib/lean/Lean/Data/KVMap.olean", + "sha256": "b69b36c839f87d7982c58dca02516af56a62b6e6f8cfed957727ab6fa5bdc3ac" + }, + "Lean.Data.LBool": { + "relative_path": "lib/lean/Lean/Data/LBool.olean", + "sha256": "e53d3d54cbdd02e971cade214336ed88039217dac49083fe9e2884774bc65980" + }, + "Lean.Data.LOption": { + "relative_path": "lib/lean/Lean/Data/LOption.olean", + "sha256": "ef57f5ca74f00d15e3353c7372bfd6539fad887f98eeb1405fc120f63fbc5450" + }, + "Lean.Data.Lsp": { + "relative_path": "lib/lean/Lean/Data/Lsp.olean", + "sha256": "5e8f95b054cf4f0bd78d09d3b60f8212677ebbcc9669810a4d555c12dbbe2c9d" + }, + "Lean.Data.Lsp.Basic": { + "relative_path": "lib/lean/Lean/Data/Lsp/Basic.olean", + "sha256": "10bd55152d2d3195bc716586b88ba354117a1610a511d4ef45e5bae4e47da591" + }, + "Lean.Data.Lsp.CancelParams": { + "relative_path": "lib/lean/Lean/Data/Lsp/CancelParams.olean", + "sha256": "34d5045104a2ad488db0eef5506fb5d152a50eb3b218963958249909e0693fc5" + }, + "Lean.Data.Lsp.Capabilities": { + "relative_path": "lib/lean/Lean/Data/Lsp/Capabilities.olean", + "sha256": "ea086554ff056336572f390c3a721392fc0a091b1e3ad5b11a1cbcfde01acb7d" + }, + "Lean.Data.Lsp.Client": { + "relative_path": "lib/lean/Lean/Data/Lsp/Client.olean", + "sha256": "66969eb1b65d7b7c0785a7410441db19c0684e49523b99141c98e9d6de265b1c" + }, + "Lean.Data.Lsp.CodeActions": { + "relative_path": "lib/lean/Lean/Data/Lsp/CodeActions.olean", + "sha256": "aaf6f59e076f612c399dc153b8655c630e5e8d3900d0c34e0754af24363fb5db" + }, + "Lean.Data.Lsp.Communication": { + "relative_path": "lib/lean/Lean/Data/Lsp/Communication.olean", + "sha256": "ff24b3db4d74dee7c02f3b312dfbcd8808ad401059a6e620467de85d2eae4b02" + }, + "Lean.Data.Lsp.Diagnostics": { + "relative_path": "lib/lean/Lean/Data/Lsp/Diagnostics.olean", + "sha256": "fab551e98e02150756f22d91f045edd2885311b0f2acd3b9f2518a03ac5315d1" + }, + "Lean.Data.Lsp.Extra": { + "relative_path": "lib/lean/Lean/Data/Lsp/Extra.olean", + "sha256": "328a92e6483fa971c03bc5c81df3fb8d54638f2b63589227cd51c150c184c6b3" + }, + "Lean.Data.Lsp.InitShutdown": { + "relative_path": "lib/lean/Lean/Data/Lsp/InitShutdown.olean", + "sha256": "6a4a2bdd2b9c291879021e2ac05ebb1766e5261b8eacce52931e0e3456e83582" + }, + "Lean.Data.Lsp.Internal": { + "relative_path": "lib/lean/Lean/Data/Lsp/Internal.olean", + "sha256": "7ac2bdcbc98918536b8dbc74f690ef33efa3d8f262d9da00b9745674124fa0f2" + }, + "Lean.Data.Lsp.Ipc": { + "relative_path": "lib/lean/Lean/Data/Lsp/Ipc.olean", + "sha256": "4655e8e87c7be2dee1388ddf2859e22126ff8e459049c7ae78b1f8c423523f60" + }, + "Lean.Data.Lsp.LanguageFeatures": { + "relative_path": "lib/lean/Lean/Data/Lsp/LanguageFeatures.olean", + "sha256": "9076799ae1e2a126180f4b65b4ba70bd0587000bbba075a49ede2e652940f648" + }, + "Lean.Data.Lsp.TextSync": { + "relative_path": "lib/lean/Lean/Data/Lsp/TextSync.olean", + "sha256": "661e837c6457b276db0fc3ff7b83c025daed1e81f1d119fa2bd8d8f703507212" + }, + "Lean.Data.Lsp.Utf16": { + "relative_path": "lib/lean/Lean/Data/Lsp/Utf16.olean", + "sha256": "3b966b6509a39ebdcfad59afb26a19c8b1ba431328424700a06d2f157e4628a2" + }, + "Lean.Data.Lsp.Window": { + "relative_path": "lib/lean/Lean/Data/Lsp/Window.olean", + "sha256": "80692ee76bcb8185fa3f79531823189b4aec6a02471db5978a0d41c260482632" + }, + "Lean.Data.Lsp.Workspace": { + "relative_path": "lib/lean/Lean/Data/Lsp/Workspace.olean", + "sha256": "9e2c734db08fbbf1a7eecf54afa2f4e6b2c4823fbfec4a700ca1ede9cbf099a8" + }, + "Lean.Data.Name": { + "relative_path": "lib/lean/Lean/Data/Name.olean", + "sha256": "608a86b16dc2e68888780aace6bf3c444be9ca982fbe05c0722b24a5941114cf" + }, + "Lean.Data.NameMap": { + "relative_path": "lib/lean/Lean/Data/NameMap.olean", + "sha256": "ad3950d1e39be7f250a74794819b4c299fd8aad0b95a8ebf383f713c4648667b" + }, + "Lean.Data.NameTrie": { + "relative_path": "lib/lean/Lean/Data/NameTrie.olean", + "sha256": "7b0032738d09c94b21eedfb74e920ce5781c864cc1541e28b9216f2296a3f50a" + }, + "Lean.Data.OpenDecl": { + "relative_path": "lib/lean/Lean/Data/OpenDecl.olean", + "sha256": "11d3c7dfac1707956e6ad5f8d99249971cefd2439d94b1042efcf1147a609848" + }, + "Lean.Data.Options": { + "relative_path": "lib/lean/Lean/Data/Options.olean", + "sha256": "69369d0818d266e890c00e318f186fdb767b308ec0ffa12c8d498ad8ab8dafd4" + }, + "Lean.Data.PersistentArray": { + "relative_path": "lib/lean/Lean/Data/PersistentArray.olean", + "sha256": "14912531f574091502391030308b9fe1d9d6751b946af2614e19472c009ed084" + }, + "Lean.Data.PersistentHashMap": { + "relative_path": "lib/lean/Lean/Data/PersistentHashMap.olean", + "sha256": "1eb926bd3f03db27a647b1dd1ae1606722f7f8bd555a8c9e4197e00d69af8819" + }, + "Lean.Data.PersistentHashSet": { + "relative_path": "lib/lean/Lean/Data/PersistentHashSet.olean", + "sha256": "bbe6fe443d42b01b3ee7c45908dd2761f3e0996e47c6d05531bfd326b82a1927" + }, + "Lean.Data.Position": { + "relative_path": "lib/lean/Lean/Data/Position.olean", + "sha256": "1031cb2dd0a833b50284a503a02c8f71490d93182219e9b2e43c536370992719" + }, + "Lean.Data.PrefixTree": { + "relative_path": "lib/lean/Lean/Data/PrefixTree.olean", + "sha256": "1cfc295f1fee5de8bb9c641f6c6a67ed4d24b3cea24af1b44ce8baae361860d7" + }, + "Lean.Data.RArray": { + "relative_path": "lib/lean/Lean/Data/RArray.olean", + "sha256": "6846f637e7f46e1ed281043406f082980d0db3c56fd1fc34fd080be3e743b11a" + }, + "Lean.Data.RBMap": { + "relative_path": "lib/lean/Lean/Data/RBMap.olean", + "sha256": "ecdafd26877ccf099c7ad634090493a314130ddb1f511402e869f833179f677a" + }, + "Lean.Data.RBTree": { + "relative_path": "lib/lean/Lean/Data/RBTree.olean", + "sha256": "4a1139cda04f91a7a78086a92cbfa53af7cd5ed0b04f50f388e91caba39e72c4" + }, + "Lean.Data.SMap": { + "relative_path": "lib/lean/Lean/Data/SMap.olean", + "sha256": "1af0bd0e0119f17204517f5b0e3ae76e582ad139d167e04d4b872c3b80fb9446" + }, + "Lean.Data.SSet": { + "relative_path": "lib/lean/Lean/Data/SSet.olean", + "sha256": "3ce020534c8de2eaaf8b72fdc30dfeff283d9fdf9cb402ee7eaa9d6e06bed49a" + }, + "Lean.Data.Trie": { + "relative_path": "lib/lean/Lean/Data/Trie.olean", + "sha256": "425b99d0861d274a027650fd85e91fe2ea4c8d2b332c26f05ce3faa69f8b22a9" + }, + "Lean.Data.Xml": { + "relative_path": "lib/lean/Lean/Data/Xml.olean", + "sha256": "3051520fc1f5e8969c97cd69b2e390cc0291e716af0304ca910917ca40c395b6" + }, + "Lean.Data.Xml.Basic": { + "relative_path": "lib/lean/Lean/Data/Xml/Basic.olean", + "sha256": "b78909fa2d132e4733174d2ce5edb87022889a3c00034a5600c37366d1249798" + }, + "Lean.Data.Xml.Parser": { + "relative_path": "lib/lean/Lean/Data/Xml/Parser.olean", + "sha256": "ef6845551edad3dd21f97bc12796643808c3e736f98ea92cd3836de8d120f896" + }, + "Lean.Declaration": { + "relative_path": "lib/lean/Lean/Declaration.olean", + "sha256": "34e3ddb2ffb4c62a725faaa32d867b47ce0f0e88e4d05b88cb4b0e8d06afcf14" + }, + "Lean.DeclarationRange": { + "relative_path": "lib/lean/Lean/DeclarationRange.olean", + "sha256": "0acae02702629cf9d8d1914af744e4616b1a11ec0c36b87b061ddb544de6c77f" + }, + "Lean.DocString": { + "relative_path": "lib/lean/Lean/DocString.olean", + "sha256": "a3acd1c0a67f2041105b56e4358104b944cccadaf6282f51d2d6c92c588e1322" + }, + "Lean.DocString.Add": { + "relative_path": "lib/lean/Lean/DocString/Add.olean", + "sha256": "4e2edfbc5d94f30cb22899dd904adf4e886c31d74a14b4867d5e6990ae6bef1f" + }, + "Lean.DocString.Extension": { + "relative_path": "lib/lean/Lean/DocString/Extension.olean", + "sha256": "62da3e2b1a78c1564bc55d7a62a3dd0bf3a5bb680c78b064545b34f22ff5f594" + }, + "Lean.DocString.Links": { + "relative_path": "lib/lean/Lean/DocString/Links.olean", + "sha256": "cb06ad02ed13e3becad26e41c65955dc450c95efd3c03c7e243480eb441a280e" + }, + "Lean.Elab": { + "relative_path": "lib/lean/Lean/Elab.olean", + "sha256": "fb002575329248f441db46568924da0347c0fc94899a897d260ed87e8b060d3a" + }, + "Lean.Elab.App": { + "relative_path": "lib/lean/Lean/Elab/App.olean", + "sha256": "7f2ef3399ca2be27e53f782db9299d1262626709416ecbde404d3044360c20e2" + }, + "Lean.Elab.Arg": { + "relative_path": "lib/lean/Lean/Elab/Arg.olean", + "sha256": "43fcac69dfb8c829f70e5c25b51a6864a5926de26a7f59d59b3434c77d2a4b70" + }, + "Lean.Elab.Attributes": { + "relative_path": "lib/lean/Lean/Elab/Attributes.olean", + "sha256": "a5a66de9739bb05ccb5303622d7e370cb631c209bade735a5a9263a16f2e994e" + }, + "Lean.Elab.AutoBound": { + "relative_path": "lib/lean/Lean/Elab/AutoBound.olean", + "sha256": "bf849b5b3131ab0c7cd465721e2bff12b3007ab05787e45d9c45cfe31dbcd8d9" + }, + "Lean.Elab.AuxDef": { + "relative_path": "lib/lean/Lean/Elab/AuxDef.olean", + "sha256": "a48e7422c13ae3730a198f9535a2a4f1d52af7ddff79a8e3e44f17e382bded85" + }, + "Lean.Elab.BinderPredicates": { + "relative_path": "lib/lean/Lean/Elab/BinderPredicates.olean", + "sha256": "f19b46d5afb2ed4f25501c99c971d43ef80056b1b54537acfab9b844b4baa033" + }, + "Lean.Elab.Binders": { + "relative_path": "lib/lean/Lean/Elab/Binders.olean", + "sha256": "5382842df889f912fcdc6829b4da03bccb31d24f644c9dc267d549a049f1f6e2" + }, + "Lean.Elab.BindersUtil": { + "relative_path": "lib/lean/Lean/Elab/BindersUtil.olean", + "sha256": "dab5459f96c9af7151e019d42c16f735587fe9d2e465680af5542694045d024e" + }, + "Lean.Elab.BuiltinCommand": { + "relative_path": "lib/lean/Lean/Elab/BuiltinCommand.olean", + "sha256": "e8873e484147230a2d52ed220e5d991242e27b35cb3e04ac44a121b4e60674e6" + }, + "Lean.Elab.BuiltinEvalCommand": { + "relative_path": "lib/lean/Lean/Elab/BuiltinEvalCommand.olean", + "sha256": "c9ffac4f0e2a910c88b947565e7186e7496b2bb71a51d3efa8b57df1716e2721" + }, + "Lean.Elab.BuiltinNotation": { + "relative_path": "lib/lean/Lean/Elab/BuiltinNotation.olean", + "sha256": "a8854418983a3521ac0009f1d1bc5886cbee99a420b5853c955e2bba669c8a01" + }, + "Lean.Elab.BuiltinTerm": { + "relative_path": "lib/lean/Lean/Elab/BuiltinTerm.olean", + "sha256": "d1c759f9d638631d8c7fcc61d904c4b3022e467c85374536404b62bcae94dbfa" + }, + "Lean.Elab.Calc": { + "relative_path": "lib/lean/Lean/Elab/Calc.olean", + "sha256": "517858cf70dbd5a3567f8c7efa08ebb072924f0ab475d1ea392d2d71f404a067" + }, + "Lean.Elab.CheckTactic": { + "relative_path": "lib/lean/Lean/Elab/CheckTactic.olean", + "sha256": "4ee79b7594813f45a0be34f47d7dcb9040038d236c08d62d075bb533cd209a06" + }, + "Lean.Elab.Command": { + "relative_path": "lib/lean/Lean/Elab/Command.olean", + "sha256": "d70527ba43f3a254e944e0951c798896a50306d8eb16d8caf346cc2c8de2037e" + }, + "Lean.Elab.ComputedFields": { + "relative_path": "lib/lean/Lean/Elab/ComputedFields.olean", + "sha256": "8aa833985762117070e65be8efd47e1105136cb60c5dce5bd1c3d9b777829778" + }, + "Lean.Elab.Config": { + "relative_path": "lib/lean/Lean/Elab/Config.olean", + "sha256": "ab8b7261941780805d87f6cd63432afa539d6810b16b3728dfa0be2722c36bd4" + }, + "Lean.Elab.DeclModifiers": { + "relative_path": "lib/lean/Lean/Elab/DeclModifiers.olean", + "sha256": "082924ed9a1233708427a204ac06d00058e16efc75a4fbf2b05260bd4b4d23d9" + }, + "Lean.Elab.DeclNameGen": { + "relative_path": "lib/lean/Lean/Elab/DeclNameGen.olean", + "sha256": "3074bf25442d70036c97fadd21d83594e0b375d89a203068ccdcfbd5ac0778ab" + }, + "Lean.Elab.DeclUtil": { + "relative_path": "lib/lean/Lean/Elab/DeclUtil.olean", + "sha256": "60ed8c5034fdb91d96f0d29a947ae510e6aa2d2c8144c82d941b33d8a236cef2" + }, + "Lean.Elab.Declaration": { + "relative_path": "lib/lean/Lean/Elab/Declaration.olean", + "sha256": "60127f7068dd6080656cc0b8fc28c04e2297a8c22ed96c5ebc6a940bb746f3d6" + }, + "Lean.Elab.DeclarationRange": { + "relative_path": "lib/lean/Lean/Elab/DeclarationRange.olean", + "sha256": "4f693d72400c7b0083dc440da6cd99962551af0a31fcdc5f23ad218b4c1cf9ba" + }, + "Lean.Elab.DefView": { + "relative_path": "lib/lean/Lean/Elab/DefView.olean", + "sha256": "4b0690fe469dcc04235e5f1db28aca28c0a1d1890622e846894836d8465cbe27" + }, + "Lean.Elab.Deriving": { + "relative_path": "lib/lean/Lean/Elab/Deriving.olean", + "sha256": "ce2343744dcd7113446dba7686175adce1b219cfa3e2a02b883dc96c83ba7492" + }, + "Lean.Elab.Deriving.BEq": { + "relative_path": "lib/lean/Lean/Elab/Deriving/BEq.olean", + "sha256": "9ee4fb8b5a18bc9a71a2188781679f93e6f7084d7166d0abca3348a2ea069748" + }, + "Lean.Elab.Deriving.Basic": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Basic.olean", + "sha256": "1ce625bec288e07f709d51fce4479fa7c90fa26229a535dbf101fb15f094b1f4" + }, + "Lean.Elab.Deriving.DecEq": { + "relative_path": "lib/lean/Lean/Elab/Deriving/DecEq.olean", + "sha256": "02f7fe725e01d8646ab570659983869355626c34eba194247edcef78ec767253" + }, + "Lean.Elab.Deriving.FromToJson": { + "relative_path": "lib/lean/Lean/Elab/Deriving/FromToJson.olean", + "sha256": "02247476a022d1f65eedd2bd2edc694bd4dad5f4766c175b99613a7f7573c7a8" + }, + "Lean.Elab.Deriving.Hashable": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Hashable.olean", + "sha256": "d6a8f5480a4d92cad91e38425026a73585933acdea29983327c6847c2b262f88" + }, + "Lean.Elab.Deriving.Inhabited": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Inhabited.olean", + "sha256": "39f9db1e14cd9748ee9fa5d6a892f8aea231b94d854d6b18d8386ef424f71e2d" + }, + "Lean.Elab.Deriving.Nonempty": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Nonempty.olean", + "sha256": "99cf8010b9439d9586ec46c94e4667b1a779478c343adeddb8744e3e9a40b8f6" + }, + "Lean.Elab.Deriving.Ord": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Ord.olean", + "sha256": "4a047b2d5dfcd783ad4004184a3752bd8a7ab07dd8a694e097d1d935e2935e9e" + }, + "Lean.Elab.Deriving.Repr": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Repr.olean", + "sha256": "6b3f39ea3a48df4fcdc3f54f23443e518331051c09c139e251e24e08830be248" + }, + "Lean.Elab.Deriving.SizeOf": { + "relative_path": "lib/lean/Lean/Elab/Deriving/SizeOf.olean", + "sha256": "e92edf4220bbfd45b65b0fec728a4e4d4cd94681b03bba266afa98e2615b9723" + }, + "Lean.Elab.Deriving.ToExpr": { + "relative_path": "lib/lean/Lean/Elab/Deriving/ToExpr.olean", + "sha256": "d6523a528599743a7df654f5743b1528f21614d72a44f3abe2aa8a28d3bd648d" + }, + "Lean.Elab.Deriving.TypeName": { + "relative_path": "lib/lean/Lean/Elab/Deriving/TypeName.olean", + "sha256": "c4792fb38b5aeb5ea5a62636aff5f757d361aa8efd4f18c67004aae538a459b7" + }, + "Lean.Elab.Deriving.Util": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Util.olean", + "sha256": "c12884adaa0c778910c1bb93eaed6108bdaea5154acf789cfade6ed2d07bc557" + }, + "Lean.Elab.Do": { + "relative_path": "lib/lean/Lean/Elab/Do.olean", + "sha256": "f7edfae85cb0c26decf417da2b632bd988396e64b591ed1e83d80007039803f3" + }, + "Lean.Elab.ElabRules": { + "relative_path": "lib/lean/Lean/Elab/ElabRules.olean", + "sha256": "f9382a01adb96c2df46c91c3b8f089161a092e303fa6c21f6ee11e052b6ff4a2" + }, + "Lean.Elab.Eval": { + "relative_path": "lib/lean/Lean/Elab/Eval.olean", + "sha256": "7c71d21984db41ed525d830c97c499f6b6bb94896b3ef708a3f0f3c3992816be" + }, + "Lean.Elab.Exception": { + "relative_path": "lib/lean/Lean/Elab/Exception.olean", + "sha256": "c1966d832888ab689c6fb710ec26064030ce9114979ba2be5b55438d3a588875" + }, + "Lean.Elab.Extra": { + "relative_path": "lib/lean/Lean/Elab/Extra.olean", + "sha256": "e04aa742507f1f8ce71235aee3e0410a0349afcce02af8033eda84793fd3cb07" + }, + "Lean.Elab.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Frontend.olean", + "sha256": "8a78aa55e40dc042d0ef7ee6eb0ac9a8e32e69499d416edbeaf41a87389bdfcc" + }, + "Lean.Elab.GenInjective": { + "relative_path": "lib/lean/Lean/Elab/GenInjective.olean", + "sha256": "71e9b7c42d5c7ba361b678074beaa897c5d59561f84b92e61be9bce93ba1516c" + }, + "Lean.Elab.GuardMsgs": { + "relative_path": "lib/lean/Lean/Elab/GuardMsgs.olean", + "sha256": "c31104fae5363b5f9b40b457899730f0bf09cb532dbdba7019768a491bfbe033" + }, + "Lean.Elab.Import": { + "relative_path": "lib/lean/Lean/Elab/Import.olean", + "sha256": "942d562b54b0f9c16191c1dc631a63c61242e662bb6b20a96c21aca07febd4a2" + }, + "Lean.Elab.Inductive": { + "relative_path": "lib/lean/Lean/Elab/Inductive.olean", + "sha256": "c0773865c8c9ed8cf8dd1799819033f043b272ece64a17dcfca9c393fc65d4d1" + }, + "Lean.Elab.InfoTree": { + "relative_path": "lib/lean/Lean/Elab/InfoTree.olean", + "sha256": "e70760b7a719b09450ee47e653758f4b04bf770d2540ecdad9c68e1ff9dcffb1" + }, + "Lean.Elab.InfoTree.InlayHints": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/InlayHints.olean", + "sha256": "9ba09f4498147935a7cc795b4dbeb9c50d057cf40bd69dc080cabcb53c6f528a" + }, + "Lean.Elab.InfoTree.Main": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/Main.olean", + "sha256": "1d24d8fe2cf5c200615e2441353a8f2ccb183bd92272ad1a91c143f037e59159" + }, + "Lean.Elab.InfoTree.Types": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/Types.olean", + "sha256": "f5ef787b574b053eb6c4dedb63628dcab9c3323860e03b9f1689b919f5a43ea6" + }, + "Lean.Elab.InfoTrees": { + "relative_path": "lib/lean/Lean/Elab/InfoTrees.olean", + "sha256": "6d9c5aef462dd3f15682d204244f1f309fe21ef6ef10afb72805a052e7360f97" + }, + "Lean.Elab.InheritDoc": { + "relative_path": "lib/lean/Lean/Elab/InheritDoc.olean", + "sha256": "13baf3bf2e721fe666937e96ef2e4c05b29802168cdbd1dbcb5024ff90c12808" + }, + "Lean.Elab.LetRec": { + "relative_path": "lib/lean/Lean/Elab/LetRec.olean", + "sha256": "25dedf0d0c914e81ba7d5f40d8cac33b777717b8587e668add128fd532e0a129" + }, + "Lean.Elab.Level": { + "relative_path": "lib/lean/Lean/Elab/Level.olean", + "sha256": "6a2e73a7585f6edbc7aa991ced908c75f6a0b6677c602f9688c2187f4e424507" + }, + "Lean.Elab.Macro": { + "relative_path": "lib/lean/Lean/Elab/Macro.olean", + "sha256": "6d4ddaaad390cc33240dabfe92351ce1b4475bc00e2bfc13a1e7d1275b731e9c" + }, + "Lean.Elab.MacroArgUtil": { + "relative_path": "lib/lean/Lean/Elab/MacroArgUtil.olean", + "sha256": "66055bb8c852b726c6c019c0ea30d9680da2b79d0f7281bae9dd6aac4e69c745" + }, + "Lean.Elab.MacroRules": { + "relative_path": "lib/lean/Lean/Elab/MacroRules.olean", + "sha256": "87258a9723089efebfd06f4fd21de2d60819043181f411caf52db4e4d61c9269" + }, + "Lean.Elab.Match": { + "relative_path": "lib/lean/Lean/Elab/Match.olean", + "sha256": "f96ca7fa6ad4572f2e70f9caf0017d6b703f6343f966146652b6a4567e075ecb" + }, + "Lean.Elab.MatchAltView": { + "relative_path": "lib/lean/Lean/Elab/MatchAltView.olean", + "sha256": "bcc410a60ab916611cd1314ccb349d1e6291534e2f54f1acc879ae5dd92e127e" + }, + "Lean.Elab.MatchExpr": { + "relative_path": "lib/lean/Lean/Elab/MatchExpr.olean", + "sha256": "c4a41299da81eb484f5ed9c1f11a2ea202f408aedd6f89eec668ec2309a05668" + }, + "Lean.Elab.Mixfix": { + "relative_path": "lib/lean/Lean/Elab/Mixfix.olean", + "sha256": "9a948b85420661584f24c9c1adb6e9de9d89e53b1c9a71f91ebc0c27b7664c6b" + }, + "Lean.Elab.MutualDef": { + "relative_path": "lib/lean/Lean/Elab/MutualDef.olean", + "sha256": "1f9b71fb58473a9ed15668ce35710aadb27f433aa3d403cb989ae40f4f22c468" + }, + "Lean.Elab.MutualInductive": { + "relative_path": "lib/lean/Lean/Elab/MutualInductive.olean", + "sha256": "cadab2c90a0b83ef83df3405057155eceeb5335b3496f9f380677d08a5d03cf0" + }, + "Lean.Elab.Notation": { + "relative_path": "lib/lean/Lean/Elab/Notation.olean", + "sha256": "48412518cf3a658eae49c64cc1467c82b71bc9d8210744b25af28f2c920335ed" + }, + "Lean.Elab.Open": { + "relative_path": "lib/lean/Lean/Elab/Open.olean", + "sha256": "871d01b5e8a7d02623aae31186f1d6440de1e88cfa5a61aa65d49bc339b801b1" + }, + "Lean.Elab.ParseImportsFast": { + "relative_path": "lib/lean/Lean/Elab/ParseImportsFast.olean", + "sha256": "e7c263fcce8f9f845a93cbacd4270d29f526c6f49542bfd3fabda67b7bf6a78a" + }, + "Lean.Elab.PatternVar": { + "relative_path": "lib/lean/Lean/Elab/PatternVar.olean", + "sha256": "cc24f76e8a73bb74fa086ffc0ca15b83727e9fe862a2bebeb5ef951d328568ec" + }, + "Lean.Elab.PreDefinition": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition.olean", + "sha256": "cf08e93464411219890b4cb1bab8e1610a70a4fb65e43b50bd739539ef367547" + }, + "Lean.Elab.PreDefinition.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Basic.olean", + "sha256": "e37a918d0df8abd0297fe32ffe904d12705e71a5098c0c3299788bec711135d8" + }, + "Lean.Elab.PreDefinition.EqUnfold": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/EqUnfold.olean", + "sha256": "3461b20ecf2a82f12d463ada0c8741fa66ee5d67ad1f6baf6e744166ccecb007" + }, + "Lean.Elab.PreDefinition.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Eqns.olean", + "sha256": "19c4d86d1bc0cb30d41db8fee326500bff23ce73f35d422a577d118a346c3f4c" + }, + "Lean.Elab.PreDefinition.FixedParams": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/FixedParams.olean", + "sha256": "0b2ab92716760dec18c20cef92a923f45ced48471005b89968dc44cc042a7787" + }, + "Lean.Elab.PreDefinition.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Main.olean", + "sha256": "e9da272ef4937c5dea929555f1afb9c0bc5e546c46ba077dba6ecad53fc039f9" + }, + "Lean.Elab.PreDefinition.MkInhabitant": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/MkInhabitant.olean", + "sha256": "01386a0e9abb41906ebeff2b51300a35bdb976fd8f5414996e90edbe7aa71535" + }, + "Lean.Elab.PreDefinition.Mutual": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Mutual.olean", + "sha256": "7727402f03f91af4db7349660aa7d8ea7512be3c6a5a9745e4528df91b2d86e2" + }, + "Lean.Elab.PreDefinition.Nonrec.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.olean", + "sha256": "3651d817386974e312357f20f0f5b695df32636b45ad87bf257e12333522f7de" + }, + "Lean.Elab.PreDefinition.PartialFixpoint": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint.olean", + "sha256": "e66825e384ff17dc6519d4c3bbb1e2d437fb9d06ccd62c25ae39462160bb8a74" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.olean", + "sha256": "dfaf14ede280a406724d7388dfd50253eb1f72bc95053c73e5b5ec562eb13181" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Induction": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.olean", + "sha256": "ace8bf806b6e3c115ca8dca8903b2590944121d6ee15b166a9e90d26f8c65de2" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.olean", + "sha256": "ce6f69f8a60fbf4529c56fb9d180b9848c4dc94b0924669d52edadea1eea85da" + }, + "Lean.Elab.PreDefinition.Structural": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural.olean", + "sha256": "5df5e860a2941222d125302b6992dfee99076a8dfe7635e03d0067b1de52037b" + }, + "Lean.Elab.PreDefinition.Structural.BRecOn": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/BRecOn.olean", + "sha256": "43d778c2e31237bab4927df047f983f90d8e51f0c8994766eade48f3cf6ac721" + }, + "Lean.Elab.PreDefinition.Structural.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Basic.olean", + "sha256": "b9c232de8b46027f3e53de76dcd73a120fe39c3d59967a5a5d4b770687546ff6" + }, + "Lean.Elab.PreDefinition.Structural.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Eqns.olean", + "sha256": "1ab842d0ec3f072b7ef36c3c389106b6281772e9c39077183524e8a7b2df26d4" + }, + "Lean.Elab.PreDefinition.Structural.FindRecArg": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.olean", + "sha256": "22c836971360cfbae10b952afc57c8cceea7c6e0776bc4f5785db9f56231f4dc" + }, + "Lean.Elab.PreDefinition.Structural.IndGroupInfo": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.olean", + "sha256": "bcbc74eedc2f318a8b2b3f67dee27bbad4499edf1b90e1b5ef2f97392829471e" + }, + "Lean.Elab.PreDefinition.Structural.IndPred": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndPred.olean", + "sha256": "933c5f3adb300c234bc4b21c33ac88720ce348df0da6101f5e29e82e2c9ebd09" + }, + "Lean.Elab.PreDefinition.Structural.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Main.olean", + "sha256": "c4239a1efe6ae90a63a33c58a2a4416ad6811c5b137a4fff5e14dea0c97dbf4e" + }, + "Lean.Elab.PreDefinition.Structural.Preprocess": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Preprocess.olean", + "sha256": "da41c20561ffeedc9fa735b40812cfc6f2019cb4ae039fcc9b50bdb3c4b42beb" + }, + "Lean.Elab.PreDefinition.Structural.RecArgInfo": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.olean", + "sha256": "374c899afb685ea073722e49bbec2c586e1a3f301580147f1092dce75749f0e9" + }, + "Lean.Elab.PreDefinition.Structural.SmartUnfolding": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.olean", + "sha256": "a3bb8c3544d361c4654090f576b2f089aca1931220817eadc9e6fde12d8d2e84" + }, + "Lean.Elab.PreDefinition.TerminationHint": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/TerminationHint.olean", + "sha256": "b008cd03dae9e9eb39f7c961783c7688bb0079c86b3380e5a2acba0931c96912" + }, + "Lean.Elab.PreDefinition.TerminationMeasure": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/TerminationMeasure.olean", + "sha256": "7b6a83a24610cdb1a23a9e279cc4e2490f0984dc226172227a54b14653bc04b5" + }, + "Lean.Elab.PreDefinition.WF": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF.olean", + "sha256": "d756a42673113d104a8f1f10ec8e5266fd550ab3307d74635cff1a79dfdf50ee" + }, + "Lean.Elab.PreDefinition.WF.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Basic.olean", + "sha256": "30e303f01dd11f5bfb9bfe9f0ac7281cb267c79ee600883e9b75ec7ef3269c4a" + }, + "Lean.Elab.PreDefinition.WF.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Eqns.olean", + "sha256": "cbcee84f0b521613f3b81a830c4672dcec0ec776d61e47ac8e8a6b323e9d8dda" + }, + "Lean.Elab.PreDefinition.WF.Fix": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Fix.olean", + "sha256": "1cd3b02dd48b1739fbdd069bca0f18019590476d52d0b55f770483952212ed4c" + }, + "Lean.Elab.PreDefinition.WF.FloatRecApp": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.olean", + "sha256": "2b2b7508f7f5f71d39f30b406dc2b24879727bee44615b1eabe341e1df9438e1" + }, + "Lean.Elab.PreDefinition.WF.GuessLex": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/GuessLex.olean", + "sha256": "193a0f7bb3f60de6c3af28362ca4e34e9e5812f17dc23e55e448a949992f31df" + }, + "Lean.Elab.PreDefinition.WF.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Main.olean", + "sha256": "f877b579eeead916865fd609fde94addce79bb845e0d983e5733a88485a5766c" + }, + "Lean.Elab.PreDefinition.WF.PackMutual": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/PackMutual.olean", + "sha256": "2a5db58f9cf338b84db997411fc33bfe8e86284d92310df8c5de6e0b4319267f" + }, + "Lean.Elab.PreDefinition.WF.Preprocess": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Preprocess.olean", + "sha256": "1c2bd7a90e2254ed6d603023a49e6171f7c0d9a14b5516b28a4c216f5006fea9" + }, + "Lean.Elab.PreDefinition.WF.Rel": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Rel.olean", + "sha256": "c5bc9c3e5ac6b953c20efa66eb36629b6b957e1b043e34c4bc970e0c86aa0c11" + }, + "Lean.Elab.PreDefinition.WF.Unfold": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Unfold.olean", + "sha256": "e6f3e0b9a8ac077b6329df9ed9c09f78cd31e02841a3511420ee8e65d226bbe6" + }, + "Lean.Elab.Print": { + "relative_path": "lib/lean/Lean/Elab/Print.olean", + "sha256": "51e5f29b3d8074b0a7162eff78b664217a5dbc27efb76b145dbaea0c05c34a96" + }, + "Lean.Elab.Quotation": { + "relative_path": "lib/lean/Lean/Elab/Quotation.olean", + "sha256": "71b2f7b722ffcaeb09b2708d6bc5d6ff5cf1c17b12376699ea36d61f4b422eed" + }, + "Lean.Elab.Quotation.Precheck": { + "relative_path": "lib/lean/Lean/Elab/Quotation/Precheck.olean", + "sha256": "991a462e6701ed3ac0da579a5f9f2c7f7f666f3c9841eda19c86bb9576108653" + }, + "Lean.Elab.Quotation.Util": { + "relative_path": "lib/lean/Lean/Elab/Quotation/Util.olean", + "sha256": "f1eb03e06f604ef25245d13da5f6e5884e335fbb462b85cc25d2fddb1799a7fd" + }, + "Lean.Elab.RecAppSyntax": { + "relative_path": "lib/lean/Lean/Elab/RecAppSyntax.olean", + "sha256": "6abcf436c2719a2ec1d8bd634b141bc3276d0bf3e27e3cf005ea336fc9663bb7" + }, + "Lean.Elab.RecommendedSpelling": { + "relative_path": "lib/lean/Lean/Elab/RecommendedSpelling.olean", + "sha256": "9661fccfded1a3c1cfa6fd6ffb7d563b2884d98e4e644ab18eca9200cbebfab6" + }, + "Lean.Elab.SetOption": { + "relative_path": "lib/lean/Lean/Elab/SetOption.olean", + "sha256": "787c484587500ec3158e59ca10eebfea0af7d3083806a9471891821f6495a64d" + }, + "Lean.Elab.StructInst": { + "relative_path": "lib/lean/Lean/Elab/StructInst.olean", + "sha256": "47bb7c2c4610c8d54accb1bd6542626bb9d4b08e731135120c54cc9b9952abec" + }, + "Lean.Elab.Structure": { + "relative_path": "lib/lean/Lean/Elab/Structure.olean", + "sha256": "156b1283480708d45f2d4ccb21165c157b65fafa79490d678b5b221e6ee0b44e" + }, + "Lean.Elab.Syntax": { + "relative_path": "lib/lean/Lean/Elab/Syntax.olean", + "sha256": "6aad81137b009aa764c5d98639ee5fb600f0ce6fc27cdef1e073588a4c223986" + }, + "Lean.Elab.SyntheticMVars": { + "relative_path": "lib/lean/Lean/Elab/SyntheticMVars.olean", + "sha256": "765f17386784a6540f899b2af62be08e7b576a00a78f41584973b8fabf27d621" + }, + "Lean.Elab.Tactic": { + "relative_path": "lib/lean/Lean/Elab/Tactic.olean", + "sha256": "a8372c1c69001269930b6cbb4e881b9e8b593ac0d594e93ec7e6d361eaf3c368" + }, + "Lean.Elab.Tactic.AsAuxLemma": { + "relative_path": "lib/lean/Lean/Elab/Tactic/AsAuxLemma.olean", + "sha256": "3ab8861debb8b53d853057c0c66642079e60144679861402226630668939e906" + }, + "Lean.Elab.Tactic.BVDecide": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide.olean", + "sha256": "6736cf5da5943762151cf22c1342fc178f0f295bee9aeb7cf004c317aa45a07d" + }, + "Lean.Elab.Tactic.BVDecide.External": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/External.olean", + "sha256": "50fecaf48258db97412a2cafd593773db1dfa2339c681a31a4102f808b7a1327" + }, + "Lean.Elab.Tactic.BVDecide.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend.olean", + "sha256": "1336b674c40caf3ba24bb63e4b78ac58dee96d925c2fcc3036283109aaf823d0" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Attr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.olean", + "sha256": "7a316bf1617de928f47afdd80f6ca28befae2fe6ad6b96dac4b7e290360f579b" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVCheck": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.olean", + "sha256": "75b4d47160ec998fe08da4884247a1cea961fad7e19bf6357670f6f626d5f036" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.olean", + "sha256": "6557c91e5d2a05ba4a56c820828531dab370c1809771585e49a7b96a9a40ac75" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.olean", + "sha256": "2b22721a88841e65d1256e7d6b3a7132b26ff1197f1ca65e3be5a5eb21422d49" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.olean", + "sha256": "7f79411de643ca37c169708a76aa12321701070ad666f41c243b1c6df2f52e07" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.olean", + "sha256": "3fa0a32b34699ba1f97db7c29be8d8b88b47c47e52de12f6191d5e6327c613b4" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.olean", + "sha256": "a04f49452a90cab257db038fe0025d6e9b9f72ee3313a479b99fcac4ae1c8f13" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.olean", + "sha256": "6c4ff9969869b0ba86b098d8bb95e2caeb88bc61426a7659ec2d1e80fd3f0496" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.olean", + "sha256": "65491bfa39b0698c310a8a8878cb01596e4616627416f40ae45e0fd622709e54" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.olean", + "sha256": "980164e9c31b64c83e46c01e78ec64630226c39920485143be4e40b859da161e" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVTrace": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.olean", + "sha256": "1996eabaa1c3f4916f484b35c39a4bcc270e9a46b9592b9b6e63b28b95acd5fa" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.LRAT": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.olean", + "sha256": "a9777f4dc66bea0b57d7a9b2b750ce78d906d0bfa930cfd0b0281b5920467aba" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.olean", + "sha256": "74af1f202de4c2fbe0aeab11e5bf05bb495342404062a0db74097f35b666b423" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.olean", + "sha256": "b24d88b0fbed216dfdaf934f8653d37291af5e1288d5485736bfd75deb10c182" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.olean", + "sha256": "df98785c5e1b7e6e5114b0c1a90760ee11277742f3ec36f4834cafa51fc567a1" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.olean", + "sha256": "8abb3b652bdd68df142259c20a7e85e26fc1c7f1ad5d1111ad8574cb7251323f" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.olean", + "sha256": "07d568115382b9a9832437443a5665dd9ab05ebaaa6e613e2336083a18a5f843" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.olean", + "sha256": "5a338a9edef0294acf2e8ee6923e0b02965595576fff7b130ced1626af66fdc6" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.olean", + "sha256": "b999e4ddc8d0d2077c56af1f1a000fe53fa3e81c97b47c5bf48d4dfbc243cfd8" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.olean", + "sha256": "82d5b4e7c2ec35f28230ce0ea464680a38a439260496c2ecc624130c7177a14b" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.olean", + "sha256": "bf6a3b70f9fedd5c42111b2afd4a947fc8085947342a1123073f65558540f436" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.olean", + "sha256": "a6588498df687fb758121463de9ae1040535ceb6c317715218669e061b05a088" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.olean", + "sha256": "87a5d15e22301b1a7c50064a06e11cae3e2b3b7ae8f4db72437bd5dea8d09077" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.olean", + "sha256": "7e18d7f9c1daff3a8b7eeca9765a3933fb244156bb5a238b03fd3d6667146a57" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.olean", + "sha256": "a60b02e2a039134f7b533c911f7beed13d84812b6062b9f19185630e282912ce" + }, + "Lean.Elab.Tactic.BVDecide.LRAT": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT.olean", + "sha256": "2265489cbaad7404d01662160bc49c6036f770a8a23257ad912587b3c94c992f" + }, + "Lean.Elab.Tactic.BVDecide.LRAT.Trim": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.olean", + "sha256": "496f7c3dd081cece59390406bd9ca3d7b8280aa923e7d50e764867b0f3895546" + }, + "Lean.Elab.Tactic.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Basic.olean", + "sha256": "b7c0301d5608f70cc3b200a6c051173f74f9feffb83b1e7993b680a28e4dec4f" + }, + "Lean.Elab.Tactic.BoolToPropSimps": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BoolToPropSimps.olean", + "sha256": "d5e4ca3bfddbd7e2538e80f41161ea63be1ed1eec0bd637d064b11e4478c6737" + }, + "Lean.Elab.Tactic.BuiltinTactic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BuiltinTactic.olean", + "sha256": "72d1c873432fe4f9dff0aa9a83056dd824703fe0faa8593f5e2a186335e12c21" + }, + "Lean.Elab.Tactic.Calc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Calc.olean", + "sha256": "b22ed20091a768b533dbf3cb92b94e3dea2a22cc70e6e013bc0e932c0a92d721" + }, + "Lean.Elab.Tactic.Change": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Change.olean", + "sha256": "c3d3fe5640183577289c4f0c7dfc9a5e82953709dc9f81ab3305a64f2c972f83" + }, + "Lean.Elab.Tactic.Classical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Classical.olean", + "sha256": "dd96a577b5982c72e7c2f9cce5cf089a933ecc0614589fdd0d741b39c721b9d5" + }, + "Lean.Elab.Tactic.Config": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Config.olean", + "sha256": "18f6104d6c843452c5742a476d16659ee05d21021eefd2d72d3a9be27a4c0009" + }, + "Lean.Elab.Tactic.Congr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Congr.olean", + "sha256": "c2cbd01a116eeab3bc6d560d5b5e812915eda68ddd4fd972444df910e1ce6f07" + }, + "Lean.Elab.Tactic.Conv": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv.olean", + "sha256": "9e13c60aac36d8d5ab077fb214f9749bd03e689fd47b66fdeb65f54b42e61fcc" + }, + "Lean.Elab.Tactic.Conv.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Basic.olean", + "sha256": "36acbc413b0baecc6d1db794fdf6e9afdc393dbb0a43b4d132ed06e80af8987d" + }, + "Lean.Elab.Tactic.Conv.Change": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Change.olean", + "sha256": "d6645dd05e52922f9008332cc16dffd5e475221c524292446010a022f7180efc" + }, + "Lean.Elab.Tactic.Conv.Congr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Congr.olean", + "sha256": "b5c476623ea1b622800815da4f1d2b769643c1bdb0c4c7524bed4851276413bf" + }, + "Lean.Elab.Tactic.Conv.Delta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Delta.olean", + "sha256": "6953c32bc540eaaa79b2221b31a9eecf9d86fc5ce46e69cc8f0ad6a3f1902419" + }, + "Lean.Elab.Tactic.Conv.Pattern": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Pattern.olean", + "sha256": "8fae7911921a66098eba444b60030314b9f52f202353e586205472afdd07c068" + }, + "Lean.Elab.Tactic.Conv.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Rewrite.olean", + "sha256": "492425f642d76075007692216a7368c533ebb8e0def54334a7fbbe849baed77e" + }, + "Lean.Elab.Tactic.Conv.Simp": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Simp.olean", + "sha256": "914f50cab77467b8faa5d21c14664fa552ca6c69339ecfc798150b48b37d3272" + }, + "Lean.Elab.Tactic.Conv.Unfold": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Unfold.olean", + "sha256": "a893adf2f22bb0bae62f47d5c4b30ae3bcedc121a7ab747398e5f780262be63b" + }, + "Lean.Elab.Tactic.Delta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Delta.olean", + "sha256": "c80c125f4b2c716c5a140a18b02d0c2c2add3d4a4e749e9774b6e36a6e6d726f" + }, + "Lean.Elab.Tactic.DiscrTreeKey": { + "relative_path": "lib/lean/Lean/Elab/Tactic/DiscrTreeKey.olean", + "sha256": "90696c26393713d01d2efefc91713c23de2d2b9ea842dcd5b0be7602ef2d2d51" + }, + "Lean.Elab.Tactic.Doc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Doc.olean", + "sha256": "f7466ce696081046b90259ed10bfce6647f3e31b5b624987527aace912d6836d" + }, + "Lean.Elab.Tactic.ElabTerm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ElabTerm.olean", + "sha256": "c93025d17c141b6a8172abd80d25fd2083f061aea574ed5b5fb85752f32ef39f" + }, + "Lean.Elab.Tactic.ExposeNames": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ExposeNames.olean", + "sha256": "b5083e8a6aa77fd5d2aa2a73cdd0777e2f2e7018e6fe73f017e31220f136ab36" + }, + "Lean.Elab.Tactic.Ext": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Ext.olean", + "sha256": "41b7e7b7c44fec4c25d21754296cb2c63b901f6ec840e4d68fd5f73c0d27bf16" + }, + "Lean.Elab.Tactic.FalseOrByContra": { + "relative_path": "lib/lean/Lean/Elab/Tactic/FalseOrByContra.olean", + "sha256": "e9c4388c61790ea040377ad4794524db4078ac279c84bfda4873f93a9e286e72" + }, + "Lean.Elab.Tactic.Generalize": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Generalize.olean", + "sha256": "f508333fab3030de8fd72a5d3e269baab671664d61c9a4f9d838a86a49945533" + }, + "Lean.Elab.Tactic.Grind": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Grind.olean", + "sha256": "08be616fb5e448a7109ff7ea58dd14de1902dbe5e8df8a873ba79e4e34523c74" + }, + "Lean.Elab.Tactic.Guard": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Guard.olean", + "sha256": "f853574192c0c04c7a6fd40a04e71966bea87d164c2dfd58066119d2b273cc53" + }, + "Lean.Elab.Tactic.Induction": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Induction.olean", + "sha256": "cb71a7fa68a672ebb2f3bfa1643a418d82d0c545d5d5b2e992a46695a14f491e" + }, + "Lean.Elab.Tactic.Injection": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Injection.olean", + "sha256": "a21d54f553d5ecbeb0bb2983f5d37040186dca297ccaa8fe5457c15333f55662" + }, + "Lean.Elab.Tactic.LibrarySearch": { + "relative_path": "lib/lean/Lean/Elab/Tactic/LibrarySearch.olean", + "sha256": "aa4345322004c2831a322f51f0b28e6c846017c08fe3dc2861c6497dca393055" + }, + "Lean.Elab.Tactic.Location": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Location.olean", + "sha256": "1098b443df5ebadfee2fc68faf7038dabacb07541f38639ac31be344e1391bdf" + }, + "Lean.Elab.Tactic.Match": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Match.olean", + "sha256": "63335a98a881cb68e20bffdb30fa3771ecb62823849ae21bb31426adc5aaccc9" + }, + "Lean.Elab.Tactic.Meta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Meta.olean", + "sha256": "567713a64ca01f5b9ab6c091ed9cd25f3ae811dd96d379690824c1048238a466" + }, + "Lean.Elab.Tactic.Monotonicity": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Monotonicity.olean", + "sha256": "fa4e39f81c52c25684740ec8b522ddb1e75e2a770da086aa498542a0254bb3ab" + }, + "Lean.Elab.Tactic.NormCast": { + "relative_path": "lib/lean/Lean/Elab/Tactic/NormCast.olean", + "sha256": "8edb153050da1e5977675c29d0faa559f8ede051b8384ea592aa05c9c892e10d" + }, + "Lean.Elab.Tactic.Omega": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega.olean", + "sha256": "4b2613345cb64b57ac4f8a0183f43e1afe4138ef8eaed2158e9d053107262491" + }, + "Lean.Elab.Tactic.Omega.Core": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/Core.olean", + "sha256": "f133556a6f4675885619fb6fb25a670fb3afce9a98b14ab0b31d89b5ecb6a2ea" + }, + "Lean.Elab.Tactic.Omega.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/Frontend.olean", + "sha256": "03c91bedf7a6187e5e74519f66bda5d6e18552fa291f950f9d3310613d99013d" + }, + "Lean.Elab.Tactic.Omega.MinNatAbs": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/MinNatAbs.olean", + "sha256": "5fc208621322f361f7d3e75f63418aec5d8851c6b75bd6a39e922f0d8b0ba191" + }, + "Lean.Elab.Tactic.Omega.OmegaM": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/OmegaM.olean", + "sha256": "99de653d54903f4599f5883f5fc1fb078ca24550ff5656b10ff227552f8af2b8" + }, + "Lean.Elab.Tactic.RCases": { + "relative_path": "lib/lean/Lean/Elab/Tactic/RCases.olean", + "sha256": "cb15fe0c2bb64023666293bb14cd157c6d756fa59dc0e8aec39b8b6f28968731" + }, + "Lean.Elab.Tactic.Repeat": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Repeat.olean", + "sha256": "5f1389c2109470e537d2486218baea2f9b69842ad86150b3c78d919b589020b5" + }, + "Lean.Elab.Tactic.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rewrite.olean", + "sha256": "332ab3fca4f37076f27bbdf57e5d614923d0d1048e1e325c56a4ae5f78a3bdf0" + }, + "Lean.Elab.Tactic.Rewrites": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rewrites.olean", + "sha256": "510a661f998f5c279f14b60fec476368bb1ed9a003c3c4753c6caa2d88c349c1" + }, + "Lean.Elab.Tactic.Rfl": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rfl.olean", + "sha256": "debc83c10ccd0f91e6944c7f2409f0390766d3c90195d90b9bc3e379a5528ebf" + }, + "Lean.Elab.Tactic.ShowTerm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ShowTerm.olean", + "sha256": "1a58d3dab98f084c1e30cd1ad363f9dcce132dd3563f7f1b3a10ea4e5b982b31" + }, + "Lean.Elab.Tactic.Simp": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simp.olean", + "sha256": "7c99ed2d7fd716baaff7454c392df88cc0ed62c7717f7a3df5fde04e69b76a24" + }, + "Lean.Elab.Tactic.SimpArith": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SimpArith.olean", + "sha256": "947ba620a7f12f3039363f12e8b609b1532421e0a15de3091c7476f38200cd19" + }, + "Lean.Elab.Tactic.SimpTrace": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SimpTrace.olean", + "sha256": "71135cbb56c87c91b4654fc258dfee3c56abd5659705c75502c97bc4098f2b1b" + }, + "Lean.Elab.Tactic.Simpa": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simpa.olean", + "sha256": "ecf16470fb1388ccc43ef450a7cc9a3bea94c691d800f90b909817b14d277db2" + }, + "Lean.Elab.Tactic.Simproc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simproc.olean", + "sha256": "67adccf068a87d29a3658b600ea8d395ad93eb34518f94930e273e9dd227a998" + }, + "Lean.Elab.Tactic.SolveByElim": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SolveByElim.olean", + "sha256": "4b83ef14834e716e40e4225b7fc6e6e0be6a4fac044490fcdcea8684314e9890" + }, + "Lean.Elab.Tactic.Split": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Split.olean", + "sha256": "1d662891823face6895782eadc704cb76813e37325f70c681ac2e481219d06a2" + }, + "Lean.Elab.Tactic.Symm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Symm.olean", + "sha256": "03415c9848515aa79dac3634eda5a005dbe2d662168206bdae2d4aeebbc5c670" + }, + "Lean.Elab.Tactic.TreeTacAttr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/TreeTacAttr.olean", + "sha256": "317645bd9832a71c3d83747c516f0084c6f778a2f01a9f1725396a9ee99f9405" + }, + "Lean.Elab.Tactic.Try": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Try.olean", + "sha256": "e06377c171ef6f8d33196b70e2c138672956f14a668924bd8dbba6ede2325966" + }, + "Lean.Elab.Tactic.Unfold": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Unfold.olean", + "sha256": "a096a399bfc253d22fceda76ad31bfe1c32923302d3fc517e0736b8c2e29fb74" + }, + "Lean.Elab.Term": { + "relative_path": "lib/lean/Lean/Elab/Term.olean", + "sha256": "f96c6c457c651da44cb9aed7d0af002589a9dd635ec492029254eeb679e85703" + }, + "Lean.Elab.Time": { + "relative_path": "lib/lean/Lean/Elab/Time.olean", + "sha256": "6b9da11286e522cb54d1759a5e4f93f50dc49b537c785daca8362c216c0141ef" + }, + "Lean.Elab.Util": { + "relative_path": "lib/lean/Lean/Elab/Util.olean", + "sha256": "d17dd23eb1ff8167dfe81c18ca2d79eb2aa863ad660be8f91057f952ac60ec2e" + }, + "Lean.Environment": { + "relative_path": "lib/lean/Lean/Environment.olean", + "sha256": "f65e86963b340104aec0500759c0221ce805877552a74a222444517efea4f327" + }, + "Lean.Exception": { + "relative_path": "lib/lean/Lean/Exception.olean", + "sha256": "348180c98395bf5936594ac1a00295baf447f096c9d55de58f1ad28b80ff532e" + }, + "Lean.Expr": { + "relative_path": "lib/lean/Lean/Expr.olean", + "sha256": "b109611aabeef2b002d78f15e7d05934c7af1dc5739a2aadde294f1417e828ee" + }, + "Lean.HeadIndex": { + "relative_path": "lib/lean/Lean/HeadIndex.olean", + "sha256": "a184c76eed310d6d6e6a855f50d25e694c10a0f3be2c8c2e01aafa23113aa817" + }, + "Lean.Hygiene": { + "relative_path": "lib/lean/Lean/Hygiene.olean", + "sha256": "f8122bf1f713f1514bdbdeb3cee8090c7d524255998bdb3f077a26fbf9e33bb9" + }, + "Lean.ImportingFlag": { + "relative_path": "lib/lean/Lean/ImportingFlag.olean", + "sha256": "ce6df3c54e60e9f9741b44b6c787667ff8edea324d61df14d97c3c6be2d4a314" + }, + "Lean.InternalExceptionId": { + "relative_path": "lib/lean/Lean/InternalExceptionId.olean", + "sha256": "314fb4e2c9c8a74700fb4ba28ff8996102d6960b101dc5e8ea058928b76671e7" + }, + "Lean.KeyedDeclsAttribute": { + "relative_path": "lib/lean/Lean/KeyedDeclsAttribute.olean", + "sha256": "6965a89059d292ffd11ede6d477a9895b5742df767da760a63958167e08709da" + }, + "Lean.LabelAttribute": { + "relative_path": "lib/lean/Lean/LabelAttribute.olean", + "sha256": "f6357ee28525c80e0e1e50f30d6abc8e9c212faf66266638907f7734baf8c4a9" + }, + "Lean.Language.Basic": { + "relative_path": "lib/lean/Lean/Language/Basic.olean", + "sha256": "116198598d0a090a3f8c1ac2df76863e2c130506768f741dd96c657b4f28f62c" + }, + "Lean.Language.Lean": { + "relative_path": "lib/lean/Lean/Language/Lean.olean", + "sha256": "ec21c3356101da99d833c4dbe27da14a587b238e0dcfead17dd1954358b4e730" + }, + "Lean.Language.Lean.Types": { + "relative_path": "lib/lean/Lean/Language/Lean/Types.olean", + "sha256": "e41961572ed5c15c53ca9829747714c5157397631bd11805558205cc21d2c300" + }, + "Lean.Language.Util": { + "relative_path": "lib/lean/Lean/Language/Util.olean", + "sha256": "7a02b960729bb110fe366fa1cfc75e7974ed6c4e984488b3d41c3701bae6d021" + }, + "Lean.Level": { + "relative_path": "lib/lean/Lean/Level.olean", + "sha256": "b0a2bdff71bacb1202f1c2b034fbfcaef3a928cb8508fe31751111872644168f" + }, + "Lean.Linter": { + "relative_path": "lib/lean/Lean/Linter.olean", + "sha256": "0ad71e4ddd414f842de88817808764b12d0dbc35fb0250beb219a6aac4d105e1" + }, + "Lean.Linter.Basic": { + "relative_path": "lib/lean/Lean/Linter/Basic.olean", + "sha256": "f15c89429080e69fa9ce443c7ab1462990d6cfb127c38ce3cc2e9c3150eaf319" + }, + "Lean.Linter.Builtin": { + "relative_path": "lib/lean/Lean/Linter/Builtin.olean", + "sha256": "65bcaf73e26b3b782cc55118edee888ef878f6eb321ef6c89ba6344c8c828727" + }, + "Lean.Linter.ConstructorAsVariable": { + "relative_path": "lib/lean/Lean/Linter/ConstructorAsVariable.olean", + "sha256": "d23b80487fc0b4ffb80cfe74517b2b44c317f857288c45e9573fa5595e7c0b76" + }, + "Lean.Linter.Deprecated": { + "relative_path": "lib/lean/Lean/Linter/Deprecated.olean", + "sha256": "ee83025c6435587e7822db2d39a94f7192a3be4828e76712936a6d687c1654b5" + }, + "Lean.Linter.List": { + "relative_path": "lib/lean/Lean/Linter/List.olean", + "sha256": "72b11db674930f01297e66d6fe9168b2711db7ed0f3a8062014bbe5628431447" + }, + "Lean.Linter.MissingDocs": { + "relative_path": "lib/lean/Lean/Linter/MissingDocs.olean", + "sha256": "89abae84ca6318a0f514ad6ab9164a28db6a35afe87b77303fca87d4a725dcff" + }, + "Lean.Linter.Omit": { + "relative_path": "lib/lean/Lean/Linter/Omit.olean", + "sha256": "8e0d622b1be4f992d2355f4ec978f33899e36c6caaeca50b3394326f74cab35e" + }, + "Lean.Linter.UnusedVariables": { + "relative_path": "lib/lean/Lean/Linter/UnusedVariables.olean", + "sha256": "d5bae599fc34fe808ea8d61cefa05405ae98d97184c208c92cbe883e9dfc20ea" + }, + "Lean.Linter.Util": { + "relative_path": "lib/lean/Lean/Linter/Util.olean", + "sha256": "e983ec22a68494993b52d4bc349e4fd8ed0e73c11a7236cdcfd14c58058da4a3" + }, + "Lean.LoadDynlib": { + "relative_path": "lib/lean/Lean/LoadDynlib.olean", + "sha256": "7bbb1aa363e257a2de2975ac17e31bbf58d4d4cd328d592710e6a718e71496b4" + }, + "Lean.LocalContext": { + "relative_path": "lib/lean/Lean/LocalContext.olean", + "sha256": "1b6191a3341ed46fa6b8dbcd3f24e245ae1b8c6ab39d080f2ff5cecc2e26250e" + }, + "Lean.Log": { + "relative_path": "lib/lean/Lean/Log.olean", + "sha256": "032fbe05a131072d1b0779947f012b10687e42ee07019d7ea29fff2d100e709f" + }, + "Lean.Message": { + "relative_path": "lib/lean/Lean/Message.olean", + "sha256": "c36f1a3906e9d18d564572f38bd3b687db02b21897db07f6470025ae522ea73f" + }, + "Lean.Meta": { + "relative_path": "lib/lean/Lean/Meta.olean", + "sha256": "206cf2fcc5bef1191f930198dfb2b0cd2042bf96f47c40faaf98cc105e137809" + }, + "Lean.Meta.ACLt": { + "relative_path": "lib/lean/Lean/Meta/ACLt.olean", + "sha256": "da1c2e3e8f486413a1fee34f34a938179cfdd72342ced421b82d230af508788d" + }, + "Lean.Meta.AbstractMVars": { + "relative_path": "lib/lean/Lean/Meta/AbstractMVars.olean", + "sha256": "a3e0a762ba6c0f8852c50c993c98208b5ce37e53cd374530f2b6f2cd119a4b34" + }, + "Lean.Meta.AbstractNestedProofs": { + "relative_path": "lib/lean/Lean/Meta/AbstractNestedProofs.olean", + "sha256": "fc0a2ed4ddd5bfc2c16958b017a88d2751126cec190d0eeb80a777c6825d2fa4" + }, + "Lean.Meta.AppBuilder": { + "relative_path": "lib/lean/Lean/Meta/AppBuilder.olean", + "sha256": "7cd2bf696029e7211829c3c8152df760b2e4695304ca409a76775c196ae56549" + }, + "Lean.Meta.ArgsPacker": { + "relative_path": "lib/lean/Lean/Meta/ArgsPacker.olean", + "sha256": "a7f9e66a5cc17f1ce38ec0b459f0ca4ab7b8a4273762e2c05b35ad57626b539e" + }, + "Lean.Meta.ArgsPacker.Basic": { + "relative_path": "lib/lean/Lean/Meta/ArgsPacker/Basic.olean", + "sha256": "6d74b8180f4fbc25df85bd09ae4ff159591fd5b7ec68dc02b798cb70a79112e4" + }, + "Lean.Meta.Basic": { + "relative_path": "lib/lean/Lean/Meta/Basic.olean", + "sha256": "f12db9629e0a571e3774816fec958dbc481f79f7b8a2c4c4bbd5208e12ccc24d" + }, + "Lean.Meta.BinderNameHint": { + "relative_path": "lib/lean/Lean/Meta/BinderNameHint.olean", + "sha256": "0d948af6513e8326ed601ea521ff00b87dd6d019bd5b60bf40860a7e5f5905f8" + }, + "Lean.Meta.Canonicalizer": { + "relative_path": "lib/lean/Lean/Meta/Canonicalizer.olean", + "sha256": "9262985c3ac4e2f8b7207fdeb2bf7fbab1db0dc6581b85a26c2cc27965ec43ee" + }, + "Lean.Meta.Check": { + "relative_path": "lib/lean/Lean/Meta/Check.olean", + "sha256": "502569420ced0ae9c7c72746fe0a34b7340279a7852e922a9b8ec5c183b97235" + }, + "Lean.Meta.CheckTactic": { + "relative_path": "lib/lean/Lean/Meta/CheckTactic.olean", + "sha256": "30e7beace22600567ab8f275bda3c48c83d8d80a14a654a0f723e125eef28377" + }, + "Lean.Meta.Closure": { + "relative_path": "lib/lean/Lean/Meta/Closure.olean", + "sha256": "092e59d5c44691e648c7e6b4151d18030b17a703b124d134c3e233d952c90058" + }, + "Lean.Meta.Coe": { + "relative_path": "lib/lean/Lean/Meta/Coe.olean", + "sha256": "72cd74ba7424353c0c7acb6cd05dd27d7f27d07fa8936fd54a96141d22d7671c" + }, + "Lean.Meta.CoeAttr": { + "relative_path": "lib/lean/Lean/Meta/CoeAttr.olean", + "sha256": "16993537a5507a03ac41462d5a54030993c6e9303353d59270b5df4762af31a9" + }, + "Lean.Meta.CollectFVars": { + "relative_path": "lib/lean/Lean/Meta/CollectFVars.olean", + "sha256": "d46e2325951ddff2997f5d37f9b688edc09d75d360711d9ae51415b9ed6a6dde" + }, + "Lean.Meta.CollectMVars": { + "relative_path": "lib/lean/Lean/Meta/CollectMVars.olean", + "sha256": "b2846166247972427c1225d20859aaa46fe676c321f3e4b8943ae064d9259b1e" + }, + "Lean.Meta.CompletionName": { + "relative_path": "lib/lean/Lean/Meta/CompletionName.olean", + "sha256": "2af094a0fd892457002a8b311a318ebb1d3b347f694fa5bd3c4a710bb3d0f5ae" + }, + "Lean.Meta.CongrTheorems": { + "relative_path": "lib/lean/Lean/Meta/CongrTheorems.olean", + "sha256": "ae1d73989795378f2db8d6725484544fbf700d26861669e26ed071fb3d5aa774" + }, + "Lean.Meta.Constructions": { + "relative_path": "lib/lean/Lean/Meta/Constructions.olean", + "sha256": "bd42abcf4b09dd47d7b07f34bce755794a76f242171f34720060f743c91d7e7b" + }, + "Lean.Meta.Constructions.BRecOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/BRecOn.olean", + "sha256": "91bb12647e28558fa3562e3ef84df4f40044d7a68fa2d0a0092f9a8b52852111" + }, + "Lean.Meta.Constructions.CasesOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/CasesOn.olean", + "sha256": "827e45d478f86cf087cc904ee3c3021343ac62fcf500ced79f733a631a72c4c8" + }, + "Lean.Meta.Constructions.NoConfusion": { + "relative_path": "lib/lean/Lean/Meta/Constructions/NoConfusion.olean", + "sha256": "4428b1ecf05f66c20cbfd068963aa5778bb1dc417f84e24a99010e93618d9268" + }, + "Lean.Meta.Constructions.RecOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/RecOn.olean", + "sha256": "08d7bf9cce44bfb9da0382e248b7232936f8e9b4e04d9f01272257e2c3e93e58" + }, + "Lean.Meta.CtorRecognizer": { + "relative_path": "lib/lean/Lean/Meta/CtorRecognizer.olean", + "sha256": "dc104bc4378dcd0427c4d67654ad199261907c9434bd5e59548f1960b7918c57" + }, + "Lean.Meta.DecLevel": { + "relative_path": "lib/lean/Lean/Meta/DecLevel.olean", + "sha256": "a2eed500e45408ea6f1531256849e4e47d7cb3ccdb8621c3a44769f45d23d37a" + }, + "Lean.Meta.Diagnostics": { + "relative_path": "lib/lean/Lean/Meta/Diagnostics.olean", + "sha256": "e64e866f33cb55305ffb4588647652a034aa08108bda8e49ba7b87f5b5c09dc8" + }, + "Lean.Meta.DiscrTree": { + "relative_path": "lib/lean/Lean/Meta/DiscrTree.olean", + "sha256": "a285696f66951a789b2d325baec39c256f247a40c4c442dcc5b5c631185a590e" + }, + "Lean.Meta.DiscrTreeTypes": { + "relative_path": "lib/lean/Lean/Meta/DiscrTreeTypes.olean", + "sha256": "35157be01b47d45c6ccfb978fe042752d42b919a13c2c59df749d78df28513d1" + }, + "Lean.Meta.Eqns": { + "relative_path": "lib/lean/Lean/Meta/Eqns.olean", + "sha256": "61d27ab1c2d1ea8db95324a4612e717c5e0a8c9fd7e6bb7cb13c928f4cc63703" + }, + "Lean.Meta.Eval": { + "relative_path": "lib/lean/Lean/Meta/Eval.olean", + "sha256": "8451e897121ce84e0e443be0ad1de1177143a1960c634d31c1b373d0ec30e5a1" + }, + "Lean.Meta.ExprDefEq": { + "relative_path": "lib/lean/Lean/Meta/ExprDefEq.olean", + "sha256": "ac84eb17f56223f5cf46553327dbfa0279b437802957cb292551c592b449a502" + }, + "Lean.Meta.ExprLens": { + "relative_path": "lib/lean/Lean/Meta/ExprLens.olean", + "sha256": "b8ac1969551532255d7a2b0223a00c65bf0bc468f90e7aba64fd6c697db6bb5b" + }, + "Lean.Meta.ExprTraverse": { + "relative_path": "lib/lean/Lean/Meta/ExprTraverse.olean", + "sha256": "b0cf3399e8837d8019f29b7e42b94028b42c6fcf40bca98a498ee9a3641ff948" + }, + "Lean.Meta.ForEachExpr": { + "relative_path": "lib/lean/Lean/Meta/ForEachExpr.olean", + "sha256": "6f2ade443619ee7d60f73bc62b4e1efd7372418d4f5b28b8b8233ac2c28ce1a9" + }, + "Lean.Meta.FunInfo": { + "relative_path": "lib/lean/Lean/Meta/FunInfo.olean", + "sha256": "b855ba9c1d30fec86c39339dd3cbfef0cfcdcdb7e78c25ad04103b37abc1a9ca" + }, + "Lean.Meta.GeneralizeTelescope": { + "relative_path": "lib/lean/Lean/Meta/GeneralizeTelescope.olean", + "sha256": "5ee0c1c92441c434c043593778ed21e47badeadce84e78a99682cedfad480372" + }, + "Lean.Meta.GeneralizeVars": { + "relative_path": "lib/lean/Lean/Meta/GeneralizeVars.olean", + "sha256": "796bc3bc0a297f547b39413e39611eb8829e642e7f44da2f4cea6d0d4ef56265" + }, + "Lean.Meta.GetUnfoldableConst": { + "relative_path": "lib/lean/Lean/Meta/GetUnfoldableConst.olean", + "sha256": "2ea066ddcc64d26c2d70e77bd3c7b015c8ee3f755d10187352eb155962d91427" + }, + "Lean.Meta.GlobalInstances": { + "relative_path": "lib/lean/Lean/Meta/GlobalInstances.olean", + "sha256": "8265fb3b50c621767dc77e38921e2fe7360694ce5b7ac3e24bdc67e0c3946f57" + }, + "Lean.Meta.IndPredBelow": { + "relative_path": "lib/lean/Lean/Meta/IndPredBelow.olean", + "sha256": "c93d1f840670b555e569ac9d262d1f41decd51f3d134d54ff4e53bb542e9cb58" + }, + "Lean.Meta.Inductive": { + "relative_path": "lib/lean/Lean/Meta/Inductive.olean", + "sha256": "cbd800e5e3644765969dc14c322b700120c9dd2c3db0d499e72c13f607fb29aa" + }, + "Lean.Meta.InferType": { + "relative_path": "lib/lean/Lean/Meta/InferType.olean", + "sha256": "a9e3c61dd6022e6864ca3416c5567360975a3781076d8dedd4b93507bfe12703" + }, + "Lean.Meta.Injective": { + "relative_path": "lib/lean/Lean/Meta/Injective.olean", + "sha256": "022f6530d2761e0fd32e4a8a1d390badfe3bbf852a92bebf2269b4cacf93ac9d" + }, + "Lean.Meta.Instances": { + "relative_path": "lib/lean/Lean/Meta/Instances.olean", + "sha256": "fcc360ddf8ee95db9d62118b0c262c6695b38251dcd96f086fee6c5195966516" + }, + "Lean.Meta.IntInstTesters": { + "relative_path": "lib/lean/Lean/Meta/IntInstTesters.olean", + "sha256": "33498b0c4626bd28ce45b7a3f7996aaee28f3cea1e8a9a6cbbe6fdeb24619209" + }, + "Lean.Meta.Iterator": { + "relative_path": "lib/lean/Lean/Meta/Iterator.olean", + "sha256": "101d4d68efea3a23fbd0dc5f16e63ff16c65b391862a09feee2f7930dc671703" + }, + "Lean.Meta.KAbstract": { + "relative_path": "lib/lean/Lean/Meta/KAbstract.olean", + "sha256": "1ff48dc21dc7daa5701ec93ebf8dea8e853eb9c76c7f08df3c047b2e364c0fd6" + }, + "Lean.Meta.KExprMap": { + "relative_path": "lib/lean/Lean/Meta/KExprMap.olean", + "sha256": "a61c80321e32eb1ac29c70f05a557bc9a950b6a65d0503e94031cd21c697f84c" + }, + "Lean.Meta.LazyDiscrTree": { + "relative_path": "lib/lean/Lean/Meta/LazyDiscrTree.olean", + "sha256": "0e52ab3e1bba285513237aa0ad00ebbeca9f6f2de5e6ffed01aa0aff4ebce915" + }, + "Lean.Meta.LevelDefEq": { + "relative_path": "lib/lean/Lean/Meta/LevelDefEq.olean", + "sha256": "039d6b9b7f252227092b329102542df7d9c09edceb1aefa45fc712078c65c5d7" + }, + "Lean.Meta.LitValues": { + "relative_path": "lib/lean/Lean/Meta/LitValues.olean", + "sha256": "fc41c863bde3e203433870eb601640349cb7855f816bdebbde1a2a204c9bdace" + }, + "Lean.Meta.Match": { + "relative_path": "lib/lean/Lean/Meta/Match.olean", + "sha256": "548ceb8925264b3c53204550bfea3548b9e73b11f0124d9a7f4343aed053ad9d" + }, + "Lean.Meta.Match.Basic": { + "relative_path": "lib/lean/Lean/Meta/Match/Basic.olean", + "sha256": "ad8f2a68e4366a7c0c5939323446515ac428595f1da113a506bf12039fb16442" + }, + "Lean.Meta.Match.CaseArraySizes": { + "relative_path": "lib/lean/Lean/Meta/Match/CaseArraySizes.olean", + "sha256": "e221018a693db011a0414635b7b68c8b8388950b2c2d4731ce41a6a5576a1d57" + }, + "Lean.Meta.Match.CaseValues": { + "relative_path": "lib/lean/Lean/Meta/Match/CaseValues.olean", + "sha256": "537ddad23a87967f7088967a2a347eb108cc36e2d4e4d9ffb0a8396d65da88df" + }, + "Lean.Meta.Match.Match": { + "relative_path": "lib/lean/Lean/Meta/Match/Match.olean", + "sha256": "2e73790b9ba9e908afaec1f9636dbe6f8ca5388dd11caa89f03e0e9579138516" + }, + "Lean.Meta.Match.MatchEqs": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchEqs.olean", + "sha256": "3e0c930d82985234eaf74ec74fb3bc7dffc959608f43bd38ac33a884500315a7" + }, + "Lean.Meta.Match.MatchEqsExt": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchEqsExt.olean", + "sha256": "bfe53903e9962eeede9b619f0ba796108662c4945af59198a5834799589b1d68" + }, + "Lean.Meta.Match.MatchPatternAttr": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchPatternAttr.olean", + "sha256": "6c7c6f96c64e483fc2864cb94a9e2f1fe2570e04660100eec221bb0511e5684a" + }, + "Lean.Meta.Match.MatcherApp": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp.olean", + "sha256": "e2ed9a86cbc2817d5fa9a023ef571b6b077e2626b8c4e6799fc4f9c31bfa9520" + }, + "Lean.Meta.Match.MatcherApp.Basic": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp/Basic.olean", + "sha256": "cd872e793052ffcbbdaed58e949e35afe056e7b7177b49c70d3c5fd6cb269825" + }, + "Lean.Meta.Match.MatcherApp.Transform": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp/Transform.olean", + "sha256": "df0e6ddff62c7c9906a8704ed1338b841299acbdb0c4894eea4dd9f253824cb4" + }, + "Lean.Meta.Match.MatcherInfo": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherInfo.olean", + "sha256": "83151f202d8e0d8b58fd86326458d33e3f8f060038aaccc7909d07cfb8c4a5c6" + }, + "Lean.Meta.Match.Value": { + "relative_path": "lib/lean/Lean/Meta/Match/Value.olean", + "sha256": "0c40eecc0e0da4ec9cc2eec21580f3493911fb56c753dab89c51327bfb64551a" + }, + "Lean.Meta.MatchUtil": { + "relative_path": "lib/lean/Lean/Meta/MatchUtil.olean", + "sha256": "5ff0623e662f1b1ba9035709de58345cf18417f05bf3580448d963471d4f1f93" + }, + "Lean.Meta.NatInstTesters": { + "relative_path": "lib/lean/Lean/Meta/NatInstTesters.olean", + "sha256": "3a54ef6c555c2304cd894a59b7519e7cf1138c5082ea7c6b541d2558f68d729e" + }, + "Lean.Meta.Offset": { + "relative_path": "lib/lean/Lean/Meta/Offset.olean", + "sha256": "e9bccfe44f2cb64ac53bdb8d4391720754a15706c982a7f4ee8b3c19b2001ed2" + }, + "Lean.Meta.PPGoal": { + "relative_path": "lib/lean/Lean/Meta/PPGoal.olean", + "sha256": "1ff4e4b1dd870a3fc09b5b9bd5bdf20dd4a0263d2a652b4d4d3461495e7d713b" + }, + "Lean.Meta.PProdN": { + "relative_path": "lib/lean/Lean/Meta/PProdN.olean", + "sha256": "d8b86b781fa66571ceb5087c16cac87cd37beb344e9134818bff6e4003f2a6b4" + }, + "Lean.Meta.RecursorInfo": { + "relative_path": "lib/lean/Lean/Meta/RecursorInfo.olean", + "sha256": "c7deca642d62ab08712aa143b716f781872a5e421470246d94bc9fb7dd862b47" + }, + "Lean.Meta.Reduce": { + "relative_path": "lib/lean/Lean/Meta/Reduce.olean", + "sha256": "6ae0326d4d14d180af14176daf097cf236bd4347a95d87b93a7e5996d1ae95ea" + }, + "Lean.Meta.ReduceEval": { + "relative_path": "lib/lean/Lean/Meta/ReduceEval.olean", + "sha256": "50aaeb5ac37fb6154b0e2c1c5d3085f3cf61736ec3b316ab2bd9e7d4d7babc40" + }, + "Lean.Meta.SizeOf": { + "relative_path": "lib/lean/Lean/Meta/SizeOf.olean", + "sha256": "af408b51fc723ab8bd677b7e5a84d33b6639d1e481b7f058d3e5f16200c7a5c5" + }, + "Lean.Meta.Sorry": { + "relative_path": "lib/lean/Lean/Meta/Sorry.olean", + "sha256": "56b4c84f52c8c7925b6c1a850fb91ff7d7966e113ed79a39e140ae46f5fde7a9" + }, + "Lean.Meta.Structure": { + "relative_path": "lib/lean/Lean/Meta/Structure.olean", + "sha256": "e5f9fa309279c95a5cf27878c316b302eba85e26b4aa1d6e85f5b43d6453616a" + }, + "Lean.Meta.SynthInstance": { + "relative_path": "lib/lean/Lean/Meta/SynthInstance.olean", + "sha256": "dc0a3b8ea0ef34849ba5ca57477fd5ccb37d7ccad92151d8b231f17afb86c5dd" + }, + "Lean.Meta.Tactic": { + "relative_path": "lib/lean/Lean/Meta/Tactic.olean", + "sha256": "ad4914ed10cf80c2d4a2388d6fb8af91cc2d2991c9475e8cab2eb6ba7d57ea22" + }, + "Lean.Meta.Tactic.AC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AC.olean", + "sha256": "ee57ccf20ad198b447ea1b6e0f7ceb4a6b3ae399b5dc45ca144164e7f41148fc" + }, + "Lean.Meta.Tactic.AC.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AC/Main.olean", + "sha256": "2bdbf30c5961d39ed784e11ba8bbbee10f34d882c8e515bfedfaae65c2983174" + }, + "Lean.Meta.Tactic.Acyclic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Acyclic.olean", + "sha256": "1d138ed59a13cdb5360dee24852ee3dcef4d97a3da34e175c3d5ba1a5afbfe98" + }, + "Lean.Meta.Tactic.Apply": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Apply.olean", + "sha256": "c1283b20feace19b65fc7e23af16221b8d0a14ac59dd7c70d8d0a83222e94baa" + }, + "Lean.Meta.Tactic.Assert": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Assert.olean", + "sha256": "7673647ca3e547e0078675263dc676f122d87c602266d432c78229cb716be2fe" + }, + "Lean.Meta.Tactic.Assumption": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Assumption.olean", + "sha256": "bbe1c2ac91bb85c39556a28690834034b3faff15ffa79f396f5646154597185b" + }, + "Lean.Meta.Tactic.AuxLemma": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AuxLemma.olean", + "sha256": "b621afecfc83539db089cf44ceee268d994ee0371559db2bafee8341ade61caa" + }, + "Lean.Meta.Tactic.Backtrack": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Backtrack.olean", + "sha256": "6ba89a26edd430b58166fa46607e7b7e7904172b1984de835b7eb9a584fec426" + }, + "Lean.Meta.Tactic.Cases": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Cases.olean", + "sha256": "f82be51283b6ca0a88b466e325061872da1ca78317d784222c2d4d5f095f25d9" + }, + "Lean.Meta.Tactic.Cleanup": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Cleanup.olean", + "sha256": "5daf92f058790a58da353d444701d231bc0d7ffac8ac7a641a396f71c09150d2" + }, + "Lean.Meta.Tactic.Clear": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Clear.olean", + "sha256": "829fa3bd204a603f0686f6060b474f98815ba786324b91fbf166c40783702c4b" + }, + "Lean.Meta.Tactic.Congr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Congr.olean", + "sha256": "2fe9a126baf313a410bca67c2ba600b5397776b3096845ca5bfd4c71f4065195" + }, + "Lean.Meta.Tactic.Constructor": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Constructor.olean", + "sha256": "867577fa39e8b883035764c3dc65017fdb335a365931aab74461676eb3d4ff43" + }, + "Lean.Meta.Tactic.Contradiction": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Contradiction.olean", + "sha256": "4f2fea4e956ca33f43b6958efcba64ec2f7da8199bf2e8305ea09dc0a9a387be" + }, + "Lean.Meta.Tactic.Delta": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Delta.olean", + "sha256": "b80e1e36a4f334d593cc5c2692020ccf113e0066cb9bccf59b88d706a1ed3303" + }, + "Lean.Meta.Tactic.ElimInfo": { + "relative_path": "lib/lean/Lean/Meta/Tactic/ElimInfo.olean", + "sha256": "59a71e16fbbfb5a22573b245e4d7068eee6d9b0d40b49602cdd03e0d4e9bdc5a" + }, + "Lean.Meta.Tactic.ExposeNames": { + "relative_path": "lib/lean/Lean/Meta/Tactic/ExposeNames.olean", + "sha256": "3b31fb2dba571938bce63170aadf82501c229ac457caad8427c58eef935ba444" + }, + "Lean.Meta.Tactic.Ext": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Ext.olean", + "sha256": "22bb0d168e310524c9788a3c415614b51ed048dbfd5a51652f46b0068c77b4a2" + }, + "Lean.Meta.Tactic.FVarSubst": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FVarSubst.olean", + "sha256": "8c21b3a5802e4d08978539b78c1dbb67508903b3f21978b38ef9cc57c270a27c" + }, + "Lean.Meta.Tactic.FunInd": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunInd.olean", + "sha256": "6296c74e67fb553b1bc764a5e07c2d5bbb6c4ebd3b323557c64d01267d1801ab" + }, + "Lean.Meta.Tactic.FunIndCollect": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunIndCollect.olean", + "sha256": "abb578a79335d722c9d69eef073a1ccb64c966b6b7dcdf501b9825181ea2165d" + }, + "Lean.Meta.Tactic.FunIndInfo": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunIndInfo.olean", + "sha256": "7fcea4ed90a733cf9b1d874e6c805f123f293da6379e4a658df2333f64cd5bc5" + }, + "Lean.Meta.Tactic.Generalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Generalize.olean", + "sha256": "c6b2a2530dbb3966ededa8eec4476801bc7c85e1a69c17519d2b47a6e3bb3047" + }, + "Lean.Meta.Tactic.Grind": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind.olean", + "sha256": "a4a04684e58d43aa05cb1c41eb3e18cf6af8da64c935a88fea4b41e394461a78" + }, + "Lean.Meta.Tactic.Grind.Arith": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith.olean", + "sha256": "3cb51d31133b73246d8131265dafb9cede95fc310dbe7bb4b5b7ece65b2598ad" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.olean", + "sha256": "dd481e2963c500cd4c4f686f800ae5d5ab818b1055fcd1cb95bab98516dbf96e" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.olean", + "sha256": "78cc1a489ac6c1dd48dbeae02db742ed4a0867263e877192ab4b417807b73251" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.olean", + "sha256": "bd0a7b837aeda3d44ba972c14219b3f8bf1fda4e68fa1b7b2a98b911007d6ae0" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.olean", + "sha256": "1e84cc67e9674371b9e1ee937f052ebaf33f949ee98fed97ae3e5a0af14ad8bc" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.olean", + "sha256": "bbaf4808f9bef4fd58cffdd9dbbebcaae4a275b740f912f4357bfcd71807dad1" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.olean", + "sha256": "bb82e33912900ffca9cb8b05ba27175bc5be751f59921b09f13322dff9997fdb" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.olean", + "sha256": "868752823c6951c957840f933609d6fe1dc86026fd810479862fdc3c73b84399" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.olean", + "sha256": "8092837e82e32858cfe423c1f20453c3c38a013c54abb05f872b1233cfbe8e5f" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.olean", + "sha256": "370a4249179e8a0d228121d74a22194b50afc23395fcc3d8024621527d703ac1" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.olean", + "sha256": "3c8f3c889d553bf6ef43ed0c444859e905cd162356ce04f85247b0456a4f7b4e" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Search": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.olean", + "sha256": "61aca638560fc03fc81066bda85ae7ed4cd041d810cd6ccfc22126d34acddbd5" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.olean", + "sha256": "50bd8fa6211db0a214bd45a0f0e39b717459c16a30ecb25f9cb952d8375bccef" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.olean", + "sha256": "049f36bd49ee5222ca1f80966c97b13f53c4c7d9671d9cf496d582bf1c502671" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.olean", + "sha256": "d9541c657bbd8498736f341ac0e4389234e57be3d769b33a637f951da6e098f7" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.olean", + "sha256": "2da35cd1a1295137544c382e41dbe533cd98dc6fc18c92de7a0c8986518f48ac" + }, + "Lean.Meta.Tactic.Grind.Arith.Internalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.olean", + "sha256": "1f8dbae8cba46c6011d127e73c6d23e1594b3c13079a8167c9ff0b5d55ceaeb9" + }, + "Lean.Meta.Tactic.Grind.Arith.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Inv.olean", + "sha256": "0750fb3fce8b1e8ec98480b4b6ab8360e5f205371b1d575f53357702ae2bb702" + }, + "Lean.Meta.Tactic.Grind.Arith.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Main.olean", + "sha256": "8eb37977bf901bab0ad9873bfbde7c593fbaf6ff8d0c1c6de61597ec91de58c0" + }, + "Lean.Meta.Tactic.Grind.Arith.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Model.olean", + "sha256": "52f869b8a4523f3f8327495940a786c4670cf48b997d432c20640384e7301003" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset.olean", + "sha256": "bd8b615afcb4c53f5e711d9ab7f88881785088cd9b9f81c6b80b64432a916166" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.olean", + "sha256": "817db989d2e71b096c86076070f270ce02efefcf2c4b0cc8eb35a85ffe592097" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.olean", + "sha256": "3ffe0874b9209d41c8a12f845f4a23c37ed67985952ec8cf4fba6607b0d49bb2" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.olean", + "sha256": "13e17f706763e0e5001c386f41180d240fcc3cb3bb0e5b0704b1c6e89f8690dc" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.olean", + "sha256": "2af0eddf89eb682293b49189b0ecfdb86e7b2cb70ca6983d35edba6fc47b6825" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.olean", + "sha256": "cc0adfcd94231e97e1d8a5d9fd855b4ba06f77d4974d9f60bf8fcb1fad3429cb" + }, + "Lean.Meta.Tactic.Grind.Arith.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Types.olean", + "sha256": "6438183d9d97bcba306b3c98d0c4df35f16ae24156cbd92211a215ee8e0e9508" + }, + "Lean.Meta.Tactic.Grind.Arith.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Util.olean", + "sha256": "059afefed5207fd3bb58ff11aa196e5cb4fdd3d0c2f03f70ab3a302f3fb59612" + }, + "Lean.Meta.Tactic.Grind.Attr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Attr.olean", + "sha256": "e0809449692b76c1e0ae127a742c8c83858306fe2612eb59a238e5600e6437b0" + }, + "Lean.Meta.Tactic.Grind.Beta": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Beta.olean", + "sha256": "34027591ddea6317ba5bc6f29ec01c6a1cd2dc75c8b2af5b5d5e6fede7c2813f" + }, + "Lean.Meta.Tactic.Grind.Canon": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Canon.olean", + "sha256": "7e0dcfb39fd87bd7aa566da21f8cf3e0055adf5abdfab8c4dcd92ff022cffc99" + }, + "Lean.Meta.Tactic.Grind.Cases": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Cases.olean", + "sha256": "a79fdef9eaf0a5a89b2369d0374b43efa50ef7eb137bb143aea1b6968130fcd5" + }, + "Lean.Meta.Tactic.Grind.CasesMatch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/CasesMatch.olean", + "sha256": "cae5f088bd9191b15683eb230c385d3cf95b9cc36c5aa8fd237ef6abd6240e79" + }, + "Lean.Meta.Tactic.Grind.Combinators": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Combinators.olean", + "sha256": "573a8a2af44136b8fde8d93f561948f97b61ed2b0445b4af06a07e82901b004c" + }, + "Lean.Meta.Tactic.Grind.Core": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Core.olean", + "sha256": "603facdbeba83aeb053dc352948b86af9017b6a6e7b546a1a1516f03fea9c273" + }, + "Lean.Meta.Tactic.Grind.Ctor": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Ctor.olean", + "sha256": "2e49aeb70d54c80eecfae5c718a65d31917c4d875090b306049d463db43c230b" + }, + "Lean.Meta.Tactic.Grind.Diseq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Diseq.olean", + "sha256": "712b2965e98032727d42acecf75d2845c6d20828c9aa6f4cb7346b51100c6761" + }, + "Lean.Meta.Tactic.Grind.EMatch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatch.olean", + "sha256": "b3075bba2fa4af4839446ccc345b04063a1eeaf1f396aa027550e0d67eaf46d6" + }, + "Lean.Meta.Tactic.Grind.EMatchTheorem": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.olean", + "sha256": "7e393dd56ee80f27d92e457f4c2070d2fe2831142981438b7dff6b652ed6b12e" + }, + "Lean.Meta.Tactic.Grind.ENodeKey": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ENodeKey.olean", + "sha256": "ca0345179b9421b8efb30bed06820116843d9701e9c9f84e0824a0961b5251a5" + }, + "Lean.Meta.Tactic.Grind.EqResolution": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EqResolution.olean", + "sha256": "ed9d38ede8c44a14131ac484fcaac127fd889468856ea78f158cb8f7c7c5f9e1" + }, + "Lean.Meta.Tactic.Grind.Ext": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Ext.olean", + "sha256": "a7c1cee7f1e76d45b3787d0a7c2036967fffd7c6d780dad968bc5e08e0c674c7" + }, + "Lean.Meta.Tactic.Grind.ForallProp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ForallProp.olean", + "sha256": "923892a0ed79c2156b6df9cc23f561b77dc2c935ccb9b1d95122bab0e20fef97" + }, + "Lean.Meta.Tactic.Grind.Injection": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Injection.olean", + "sha256": "7c448e2fc0d16e61b6ad822651c7b35b8213dd18fbd4927017595d9fcd96af63" + }, + "Lean.Meta.Tactic.Grind.Internalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Internalize.olean", + "sha256": "7cd74b074c2e9deae6791b7045b6dec8f9056d41b96c9072020b051d67402323" + }, + "Lean.Meta.Tactic.Grind.Intro": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Intro.olean", + "sha256": "45d35493ac631af84097a78ea4b02bc5cc814c0ac8b598b36049279ac7ed87f3" + }, + "Lean.Meta.Tactic.Grind.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Inv.olean", + "sha256": "5111a484cd46c8d2263629540e4128cef9f30b74ccf62a6eded8ac56d8481fa3" + }, + "Lean.Meta.Tactic.Grind.MBTC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MBTC.olean", + "sha256": "596858a07ca041824937bfd08b38cdef09d32b08749962546f2b8abdb7e24192" + }, + "Lean.Meta.Tactic.Grind.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Main.olean", + "sha256": "e1e5ab7d0c967a50c2a38a5490a1a8c537e843da2c3f5a56e7cda971208bfd93" + }, + "Lean.Meta.Tactic.Grind.MarkNestedProofs": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MarkNestedProofs.olean", + "sha256": "3ab8dc54fab42c6683c63aae87ad0e606b3832d1f2391087ec7e698d5fa2fbcb" + }, + "Lean.Meta.Tactic.Grind.MatchCond": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchCond.olean", + "sha256": "ab35239747c6ca8c3833e709aaa2aa723d0525620ac2634241f72963ac9bed82" + }, + "Lean.Meta.Tactic.Grind.MatchDiscrOnly": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.olean", + "sha256": "0de0cdfbedfabfa048e98e885f3f1eea39e583aec8bcc2a50a5698f7a0df7884" + }, + "Lean.Meta.Tactic.Grind.PP": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/PP.olean", + "sha256": "23d560a5339928172099a9062d083f940a0a16e6c0b784dfe2a9f356e8682bb7" + }, + "Lean.Meta.Tactic.Grind.Parser": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Parser.olean", + "sha256": "052643551a1eb5fbfe4afdca2eb7ae6260628ef93f4813744cbda5a138eb751a" + }, + "Lean.Meta.Tactic.Grind.Proj": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Proj.olean", + "sha256": "1383ad6bc4a47cea522c9b9f542049aad4b818f4bf208ed98d1f56088d322a9a" + }, + "Lean.Meta.Tactic.Grind.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Proof.olean", + "sha256": "7e5f3d9016d71c938eb5bf7c6188d50dfe2b148189748b018e13d1d1f26758c0" + }, + "Lean.Meta.Tactic.Grind.Propagate": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Propagate.olean", + "sha256": "ba25b0259e25398cb28d7a6343b76a9ffae30a0e7759f2bbba03cf439d27ee49" + }, + "Lean.Meta.Tactic.Grind.PropagatorAttr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.olean", + "sha256": "c21c3865df64f8a2bdab20ab5a5658badebe0b370640e63e7ce8ae0620bc98b3" + }, + "Lean.Meta.Tactic.Grind.ProveEq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ProveEq.olean", + "sha256": "6fd15eeee6dce37a980a5036eb99716960dbbc6650d14b71cbd63a0f854578e7" + }, + "Lean.Meta.Tactic.Grind.RevertAll": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/RevertAll.olean", + "sha256": "63335a05f51b1b99b3bc891e774ed07ae7ccf470b36701c9a47472a2023b72dc" + }, + "Lean.Meta.Tactic.Grind.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Simp.olean", + "sha256": "eb9a419af181bdcc13018b73f8b5ef9b0cce6b3d8e69bb777a9464d54d7489d0" + }, + "Lean.Meta.Tactic.Grind.SimpUtil": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/SimpUtil.olean", + "sha256": "082ec13ed64da168e10a1d19d1f2080f417e069936488d9628652d2e83bf96ab" + }, + "Lean.Meta.Tactic.Grind.Solve": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Solve.olean", + "sha256": "838552f0e3f9901c03de3ee16533956fcc7677abcd393eaa85fc7e14c67c0c07" + }, + "Lean.Meta.Tactic.Grind.Split": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Split.olean", + "sha256": "9be21a776a8dbb641a0af947eebf4525341bfa829b3ae7e7ed5eb20855727d37" + }, + "Lean.Meta.Tactic.Grind.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Types.olean", + "sha256": "50bd2bb81627e5f915ee54c8730bb4d5403de12cca8a05a41f2f280b693772f9" + }, + "Lean.Meta.Tactic.Grind.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Util.olean", + "sha256": "02603b8094844f61ba32b6173beb06896e101dac5d581ca4ef9e82b17f4ba473" + }, + "Lean.Meta.Tactic.IndependentOf": { + "relative_path": "lib/lean/Lean/Meta/Tactic/IndependentOf.olean", + "sha256": "d6abc51e9488051912586a96926f55ddb9f0368c8891d5f89ff2d684122148fe" + }, + "Lean.Meta.Tactic.Induction": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Induction.olean", + "sha256": "a8fdc96571cc600fd47e2e68d84c51fe8afc537c08ab63d1e69ba5b4f518f4fa" + }, + "Lean.Meta.Tactic.Injection": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Injection.olean", + "sha256": "6d25fe6e9d8e4af470d9cd1074402577fd08575b0306faf9c78411c8a5e7578a" + }, + "Lean.Meta.Tactic.Intro": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Intro.olean", + "sha256": "a781ab0eafda9549477f2e90e0dc6ea708bbbda6d12f7390eaba879ecf6146a7" + }, + "Lean.Meta.Tactic.LibrarySearch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/LibrarySearch.olean", + "sha256": "c943f49809c5e0037e4239b05e441c2331cb48b24ca17f9146e5197458ed3ad6" + }, + "Lean.Meta.Tactic.NormCast": { + "relative_path": "lib/lean/Lean/Meta/Tactic/NormCast.olean", + "sha256": "8758122a8aa03b65194824837c9501ff7a57f6e56c3645ce16cd39935122465b" + }, + "Lean.Meta.Tactic.Refl": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Refl.olean", + "sha256": "39762b479efc2290610ab53ea0f9a7a67643f6684cb0fa5cdc1ff52cd5589d8a" + }, + "Lean.Meta.Tactic.Rename": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rename.olean", + "sha256": "633edd2088d9aab13bbb93c7da98451571c025dd4fa28c7adb7a1f14dede0a82" + }, + "Lean.Meta.Tactic.Repeat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Repeat.olean", + "sha256": "54854192d18a935b34a838ec68e7b5c86f7efc2831bbfe623057415260b84553" + }, + "Lean.Meta.Tactic.Replace": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Replace.olean", + "sha256": "a542783069ace49d9d9e92aa9f3cb725c98f94d5cdd4977a1154569dad20f1b5" + }, + "Lean.Meta.Tactic.Revert": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Revert.olean", + "sha256": "f6454fe8a940ada423be12c9a36033ecfbba13b71d0ed59fad2e9d522d46df10" + }, + "Lean.Meta.Tactic.Rewrite": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rewrite.olean", + "sha256": "3d61c66d1f775792f0c463b3ef6666a399fff92c2f7f1b29c605c99e02941897" + }, + "Lean.Meta.Tactic.Rewrites": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rewrites.olean", + "sha256": "5a2278edd2383bca036422ea43a484ccae7a0bb2bc7e7e15f0326a32e2330786" + }, + "Lean.Meta.Tactic.Rfl": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rfl.olean", + "sha256": "d2e5e722c4f2e3c9f291c02c05a671917d71aef645e34c0c01dbfd8a4ef23898" + }, + "Lean.Meta.Tactic.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp.olean", + "sha256": "a744b6973cd9b833699a6c19c0fa40e4dbfb6041fb08a6ca4de0823d3d56fae0" + }, + "Lean.Meta.Tactic.Simp.Arith": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith.olean", + "sha256": "b8b2030520be215f2121c9fab8608f7fd58ea80e48ffa5598fce3d1f948950c1" + }, + "Lean.Meta.Tactic.Simp.Arith.Int": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int.olean", + "sha256": "4f1c85c9e598fc31a7e1fc7e6f8d06d1c1eaa5146c624842e8ec87b58e5d9994" + }, + "Lean.Meta.Tactic.Simp.Arith.Int.Basic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.olean", + "sha256": "d03e49ecd4dfdec58f2ac9f261d983bea4023df4c78f7514bb7f6c40cdbb8bbf" + }, + "Lean.Meta.Tactic.Simp.Arith.Int.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.olean", + "sha256": "2766ba66e280f3beb4bae57de6de59a2f92647472cbe608bec350dbabdaaba11" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat.olean", + "sha256": "a035ca9e9317ad56e2e70046e0864586827218ad7e25cb7366fe532e010b1007" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat.Basic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.olean", + "sha256": "f80614c7ae4ff336b04162d11f2574e0848f38f72882fe919d759eaa09590f72" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.olean", + "sha256": "d77e898ebdaa21da0b6f6fa24eb4804a8b45ecf4ed7834aa26bfe8493b51148a" + }, + "Lean.Meta.Tactic.Simp.Arith.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Util.olean", + "sha256": "e43e2fa36cc77656ee34ca02b79897664215ce95e653cada87db0781111193ff" + }, + "Lean.Meta.Tactic.Simp.Attr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Attr.olean", + "sha256": "59dacc00728793da658e06c75bf20eb166ca57c100434714c7a7b7349149e99b" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.olean", + "sha256": "9e91488ad971f433fc8c18b870ddae5174f4fd8a80f9aee7e195223acf0813e7" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.olean", + "sha256": "aba24528cdf8549fefad4371d2ed8279dcc5bd4566d9ca59ccc721f760d51c56" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.olean", + "sha256": "18ba1c46202bae2dd5205e93db1df217fc9d213fbdc687452d9d76421437ef66" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.olean", + "sha256": "70bb04834a476008fe448165e8662a0437c82012e348ec19b6039773051fc91d" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.olean", + "sha256": "5b8217fa58f2deae0b8a99202da2367fedbf91cda77486d0ea9201b05a0720ae" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.olean", + "sha256": "fe618da592aafcfc1b597b118c88b962b603f55096926e7c77cd5f237a393c0e" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.olean", + "sha256": "9535c409ebeb0c3064e5b98fa9f953fbb93e15db3f2116dc46138ac0ff700c0a" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.List": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.olean", + "sha256": "93a9382bd2f855ac48c61e6886f02b85f81593552747a1dae72b3b10afc71a70" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.olean", + "sha256": "6b8d3d8807c31912616ae4818014da1e44cbfa398eeae525170b864185b3f324" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.olean", + "sha256": "a14d545e6a296624fbfc25dc02e8a49e0be6e3285f47960af9dbb766e872a024" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.String": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.olean", + "sha256": "bae98881832f2482d6e98c1b9eb11cc28e984ee2b7ac2d3e3d92ceade31bb7c6" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.olean", + "sha256": "9afaab454e44fd3c1a60907f38ee31b9057682bb6b66503e3136b23a0e51a0eb" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.olean", + "sha256": "97194969f1662051ced0134ccd1cbc4051c02ed0afd46ecff6daafb413645652" + }, + "Lean.Meta.Tactic.Simp.Diagnostics": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Diagnostics.olean", + "sha256": "8fb74efbbe0d898b4bee2b53a996bb925cd3dfdd4bf3098086d07fdad9c093f6" + }, + "Lean.Meta.Tactic.Simp.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Main.olean", + "sha256": "90f3c5c41d8d10a7b82110a9d188db8661f730c8430102696a6050a9e819944d" + }, + "Lean.Meta.Tactic.Simp.RegisterCommand": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/RegisterCommand.olean", + "sha256": "5e296fcd42394e5fa5a137358753eb347872076a0e8dc3ef5e31b483ac58af39" + }, + "Lean.Meta.Tactic.Simp.Rewrite": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Rewrite.olean", + "sha256": "e6377cde2f937751efc04e43b032505bfed7ec5c1f13678c3cb456268e90d2c2" + }, + "Lean.Meta.Tactic.Simp.SimpAll": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpAll.olean", + "sha256": "f2aedf17c8196a3fcc3ba0a79d2dee82b6599e2623e0e5336940943fe294316d" + }, + "Lean.Meta.Tactic.Simp.SimpCongrTheorems": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.olean", + "sha256": "2a29138060df8d5e09ad070b170d167fc490713073b36b38371e676c83578119" + }, + "Lean.Meta.Tactic.Simp.SimpTheorems": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpTheorems.olean", + "sha256": "b6f48b1bf34a7832d9a809b108a3aa8606c13afd2376b6c2c79f7045425e0e7d" + }, + "Lean.Meta.Tactic.Simp.Simproc": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Simproc.olean", + "sha256": "913ac372ccd4b4445b346d16d2ba702bf74d8ea65e62401b7b502b016bc82750" + }, + "Lean.Meta.Tactic.Simp.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Types.olean", + "sha256": "382bf34c3320d34ce0ba097804f91ee702480fb358709d1a376399ab20ae2767" + }, + "Lean.Meta.Tactic.SolveByElim": { + "relative_path": "lib/lean/Lean/Meta/Tactic/SolveByElim.olean", + "sha256": "65859e5f73882352b2e665afdd9ae7f9dbd122ef99cdaa6422fc4e37c030d459" + }, + "Lean.Meta.Tactic.Split": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Split.olean", + "sha256": "0e8d4c9c735a78acc8977e81bc84bd39d2390093d889445f006ba6d5f6ad5b3d" + }, + "Lean.Meta.Tactic.SplitIf": { + "relative_path": "lib/lean/Lean/Meta/Tactic/SplitIf.olean", + "sha256": "a39ffae4f96a41e30a2c3a88468103c3c716942214fc8805357490e903b2ef67" + }, + "Lean.Meta.Tactic.Subst": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Subst.olean", + "sha256": "44938a993d4998ad3140ba161843cf52fc0f01d8eb04dc105433e74f57e13dba" + }, + "Lean.Meta.Tactic.Symm": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Symm.olean", + "sha256": "9e576fa9ccc14f72a6d4b75f9ccb133f5463c531031fc0abcd81f9ce1e002b6b" + }, + "Lean.Meta.Tactic.Try": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Try.olean", + "sha256": "e2c566144935639f447b2493030d97204d22cfb866bd8c767ec0fba491cb56c2" + }, + "Lean.Meta.Tactic.Try.Collect": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Try/Collect.olean", + "sha256": "eb58abadce47d13437cc648de8c9c4d34965bde2b5b8c0fb5be46aa7c2f709bb" + }, + "Lean.Meta.Tactic.TryThis": { + "relative_path": "lib/lean/Lean/Meta/Tactic/TryThis.olean", + "sha256": "b0a43bfa4c21d9d9c9181de4783e7f7637862e6799dc17a94ffd41b6b8320535" + }, + "Lean.Meta.Tactic.Unfold": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Unfold.olean", + "sha256": "c512bf7a8ddc53bc480ed017efccdce73fa6a65ff3bc8026fcdb45108910a8f1" + }, + "Lean.Meta.Tactic.UnifyEq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/UnifyEq.olean", + "sha256": "17895f0232b1c9b37739a6678bc125d5481c4711fd70dcc2e0d7533d2ae7d88a" + }, + "Lean.Meta.Tactic.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Util.olean", + "sha256": "26f024806a3c5a844167cad452c161e17dd535f37c2f70f76fa8d0e98ac7d898" + }, + "Lean.Meta.Transform": { + "relative_path": "lib/lean/Lean/Meta/Transform.olean", + "sha256": "0fad85dd417e805f932c54eada13d21053a7457b9154026cf16b38e3458fc759" + }, + "Lean.Meta.TransparencyMode": { + "relative_path": "lib/lean/Lean/Meta/TransparencyMode.olean", + "sha256": "8f195daac0641aeeb14c47bb8989f99929ddb79329d5b64dd4349bc21ad52fdc" + }, + "Lean.Meta.UnificationHint": { + "relative_path": "lib/lean/Lean/Meta/UnificationHint.olean", + "sha256": "f6400a3713e4a9a72e4f2ef064ebe692706c0f21f186dce75250fe6eb4138a85" + }, + "Lean.Meta.WHNF": { + "relative_path": "lib/lean/Lean/Meta/WHNF.olean", + "sha256": "13939b1cdb2a81230a5445e9836dadeead92b5810b293c5da265451f02dd516f" + }, + "Lean.MetavarContext": { + "relative_path": "lib/lean/Lean/MetavarContext.olean", + "sha256": "616fb991aae42c8780c3566eadfe5e7cbabbf4779da1cf138014130772a668e1" + }, + "Lean.Modifiers": { + "relative_path": "lib/lean/Lean/Modifiers.olean", + "sha256": "34a8b59c7358c3a176430743f45ff649c47511e16e8b38bc763e3d63d82d11ae" + }, + "Lean.MonadEnv": { + "relative_path": "lib/lean/Lean/MonadEnv.olean", + "sha256": "086512b6ccf3afb524b665d93bfa512c8d2f699dd55ee4d59acab9376c379659" + }, + "Lean.Namespace": { + "relative_path": "lib/lean/Lean/Namespace.olean", + "sha256": "a4eb3519381836c10a0afd99e58a248135c277cd2a9489cc77636877914df692" + }, + "Lean.Parser": { + "relative_path": "lib/lean/Lean/Parser.olean", + "sha256": "28d395e6f52a72577be7747cfd60a84d5fef0edbff614963675e7103f43ce066" + }, + "Lean.Parser.Attr": { + "relative_path": "lib/lean/Lean/Parser/Attr.olean", + "sha256": "d37af508df519b54e878fdf29c6ff2006c4ab3d66c189302f2e28d50fb53d01e" + }, + "Lean.Parser.Basic": { + "relative_path": "lib/lean/Lean/Parser/Basic.olean", + "sha256": "948a51872ed931dcd069d6717532f02760ec64f1acfd6862fc5d222cc6aedeb0" + }, + "Lean.Parser.Command": { + "relative_path": "lib/lean/Lean/Parser/Command.olean", + "sha256": "a095b104d809b21d76722139623c677f932cbe8f33f79077c0f7469facaa4d21" + }, + "Lean.Parser.Do": { + "relative_path": "lib/lean/Lean/Parser/Do.olean", + "sha256": "0d97f39e5ec556f827c8399724fc2c7ad26b9b7a3aa8583158c1b335d2962edc" + }, + "Lean.Parser.Extension": { + "relative_path": "lib/lean/Lean/Parser/Extension.olean", + "sha256": "3d5387205b22b17b0449553339d1449481eb01d1f90424c1920521dfbbd6a51d" + }, + "Lean.Parser.Extra": { + "relative_path": "lib/lean/Lean/Parser/Extra.olean", + "sha256": "26993ef7f1b0dc107e5a54f5346becb1ed7df9e287a9716ba9a90dc25cb5597a" + }, + "Lean.Parser.Level": { + "relative_path": "lib/lean/Lean/Parser/Level.olean", + "sha256": "028076fe879c3d1f470248400637a3b2a404bd2807c6b1c42bd9f19b37a87385" + }, + "Lean.Parser.Module": { + "relative_path": "lib/lean/Lean/Parser/Module.olean", + "sha256": "1cd96b90357d48c1313be94c170a60e06deab7c2230a7684a5d3ad39a41a1453" + }, + "Lean.Parser.StrInterpolation": { + "relative_path": "lib/lean/Lean/Parser/StrInterpolation.olean", + "sha256": "1f275289f803e6362acbbdbb64dcbd1f4b63a25d01b96104d8bad7419712270a" + }, + "Lean.Parser.Syntax": { + "relative_path": "lib/lean/Lean/Parser/Syntax.olean", + "sha256": "b7d13deae25970c03965ab71ee15b6079948b4031f5c7877b19253d75b32a9a8" + }, + "Lean.Parser.Tactic": { + "relative_path": "lib/lean/Lean/Parser/Tactic.olean", + "sha256": "1d5f60bbb0520f7381c7942188f25406b178ed74e64c6995b8136e9d410617c9" + }, + "Lean.Parser.Tactic.Doc": { + "relative_path": "lib/lean/Lean/Parser/Tactic/Doc.olean", + "sha256": "de5fa176afd2efb06130e19b1fad85a782e8f6c70abd81e07410c06bdaaf435c" + }, + "Lean.Parser.Term": { + "relative_path": "lib/lean/Lean/Parser/Term.olean", + "sha256": "c27cd04030908ee1296d32a8230508cf878e37d3d9b55dc54a33dfd8f7bbcbaf" + }, + "Lean.Parser.Term.Doc": { + "relative_path": "lib/lean/Lean/Parser/Term/Doc.olean", + "sha256": "48344268b22b852d1c35ae1a717dcd804b7e02cb6619538b521a0f9f7c5b75ec" + }, + "Lean.Parser.Types": { + "relative_path": "lib/lean/Lean/Parser/Types.olean", + "sha256": "ebb9269d0c74ef1b84ed10af9a0fcfebd8c5f06af78ea8b7de52fab501ec3801" + }, + "Lean.ParserCompiler": { + "relative_path": "lib/lean/Lean/ParserCompiler.olean", + "sha256": "dfcf227a5095244c4f18259255e84b7d7486916a13d15cc7d494bf8327e7ea01" + }, + "Lean.ParserCompiler.Attribute": { + "relative_path": "lib/lean/Lean/ParserCompiler/Attribute.olean", + "sha256": "0635f545bec6dc4635f71024582d1e77d8ea6ace85b71d596c241b8c5cbb7ae0" + }, + "Lean.PremiseSelection": { + "relative_path": "lib/lean/Lean/PremiseSelection.olean", + "sha256": "84ad62edb54be2f55ea548421e59915503f678f5a689528429cbd6b3a47f52c3" + }, + "Lean.PrettyPrinter": { + "relative_path": "lib/lean/Lean/PrettyPrinter.olean", + "sha256": "f3c54ec68adb7b306e7de49fe6e1cc53c591053f6d772c125120e35cc0e42762" + }, + "Lean.PrettyPrinter.Basic": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Basic.olean", + "sha256": "5c155123ea1a5935403072f161006d3609e769fa5971cc83b99217c93d269a70" + }, + "Lean.PrettyPrinter.Delaborator": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator.olean", + "sha256": "2832e05f38fb87dd795cde9f6529793009807c6599a36ca0655f04eceb2c216c" + }, + "Lean.PrettyPrinter.Delaborator.Attributes": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Attributes.olean", + "sha256": "f98afcbf332723561b6d466a6c129844cdaff8b8f55e79f43a0040d1a0eb6a5c" + }, + "Lean.PrettyPrinter.Delaborator.Basic": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Basic.olean", + "sha256": "e402ce6c7c87da5752f1ec58b3032275db4ee722342a55bc118ac16ccb31b129" + }, + "Lean.PrettyPrinter.Delaborator.Builtins": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Builtins.olean", + "sha256": "02e8e2ec8a01f0eeba7212f5f3731bad7811680c44c03045391acd6222e8246a" + }, + "Lean.PrettyPrinter.Delaborator.FieldNotation": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.olean", + "sha256": "0fd7dac9c26de870462ff5c02bfa167ddba6d4b6f5616e9cd0849bf410997dc1" + }, + "Lean.PrettyPrinter.Delaborator.Options": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Options.olean", + "sha256": "83038fe17fe8486d5c2d49c942c60f40a56a857ea203991d52b0877f4c96ebdd" + }, + "Lean.PrettyPrinter.Delaborator.SubExpr": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/SubExpr.olean", + "sha256": "0d284ad4e40cc16bff17d232de10dee13bfa15b68eeda439218984488a864cef" + }, + "Lean.PrettyPrinter.Delaborator.TopDownAnalyze": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.olean", + "sha256": "ae6466c25b02f08e0b5fdfa1d2905b521de447c99ed580026aeaf3fcbac14d54" + }, + "Lean.PrettyPrinter.Formatter": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Formatter.olean", + "sha256": "348c5cf96f47b9c3b5d672b87913ac267d4c9f6ab5cc6e1e46757b9a4898470f" + }, + "Lean.PrettyPrinter.Parenthesizer": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Parenthesizer.olean", + "sha256": "d11ccf31a884b96dd8e7ce4a3d0be88ee37572282cc77235996eb06283ff9e1e" + }, + "Lean.PrivateName": { + "relative_path": "lib/lean/Lean/PrivateName.olean", + "sha256": "01331d62033f1a153ccfce0e26b19eec216989653b9170e09690f3f30017cd9e" + }, + "Lean.ProjFns": { + "relative_path": "lib/lean/Lean/ProjFns.olean", + "sha256": "b4e573e1214a33dfb17c70b252e55c42d56cbaa3ee3a02b620fc3cb238587772" + }, + "Lean.ReducibilityAttrs": { + "relative_path": "lib/lean/Lean/ReducibilityAttrs.olean", + "sha256": "4474586ad1da6481575424de924659c612a3e8c6b715ddf34fc26039d2e51e29" + }, + "Lean.Replay": { + "relative_path": "lib/lean/Lean/Replay.olean", + "sha256": "b99332f1e48cab089d45ecc5b6fadb71f95adb915b95ac7d5f513b8866b65d4e" + }, + "Lean.ReservedNameAction": { + "relative_path": "lib/lean/Lean/ReservedNameAction.olean", + "sha256": "c4c0b3460d35f4083a2459f232a0ff881e69092173963b6a671550a8640b3b41" + }, + "Lean.ResolveName": { + "relative_path": "lib/lean/Lean/ResolveName.olean", + "sha256": "1c5302ed5d1925a703364dbb22a84eb835a738d1073a1f576eafb4551b2f6863" + }, + "Lean.Runtime": { + "relative_path": "lib/lean/Lean/Runtime.olean", + "sha256": "f2c44c67f19cf22efd8c35ebb08d645de14a15341ce43055392e503f90c96ebf" + }, + "Lean.ScopedEnvExtension": { + "relative_path": "lib/lean/Lean/ScopedEnvExtension.olean", + "sha256": "a81bf05e51a27486ca11bb4b7f627a71278be383d69c04380886f8be0d7fd0fe" + }, + "Lean.Server": { + "relative_path": "lib/lean/Lean/Server.olean", + "sha256": "bbd9570762b5728fbeba1cd4fb6e1e63d0dc1e2f2b117cafd9e7fcae9bad7637" + }, + "Lean.Server.AsyncList": { + "relative_path": "lib/lean/Lean/Server/AsyncList.olean", + "sha256": "d9ecedd556a8565e22c4c4ef375e498bcf46cff541631685e3c6bb59da13ec06" + }, + "Lean.Server.CodeActions": { + "relative_path": "lib/lean/Lean/Server/CodeActions.olean", + "sha256": "1ffd438b12bf14992169052902dc91ff981fbffbd5b9d9dc3cd351afadf2d924" + }, + "Lean.Server.CodeActions.Attr": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Attr.olean", + "sha256": "21177a969ea2086c19c19a7d71a2d66acd666bfbd49c77dff89a2193ab911100" + }, + "Lean.Server.CodeActions.Basic": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Basic.olean", + "sha256": "3092af6beab4d2ccbcdc4d3c493887fbc61d2fd8c6507359d8dc81515af83350" + }, + "Lean.Server.CodeActions.Provider": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Provider.olean", + "sha256": "aca19e7414b6c15aa725debc884e06aa48515bc10f78bdac847e92a0d3355945" + }, + "Lean.Server.Completion": { + "relative_path": "lib/lean/Lean/Server/Completion.olean", + "sha256": "2d2b0e130132eee10776deb68540afbf5c588598b4f858be9850099e64e8039e" + }, + "Lean.Server.Completion.CompletionCollectors": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionCollectors.olean", + "sha256": "ca660a9b742f1e2f6adf50cc33847122c9bc017880a643d63a56053091cb9f8d" + }, + "Lean.Server.Completion.CompletionInfoSelection": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionInfoSelection.olean", + "sha256": "229a4e0e5238f4af4a9165f077e381a739b385a957ec1fe5590d0329711a221d" + }, + "Lean.Server.Completion.CompletionItemData": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionItemData.olean", + "sha256": "aa592a1060191b06553a282b4e2c23583260bbd32f193fdd82a2a0e3881b2ea5" + }, + "Lean.Server.Completion.CompletionResolution": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionResolution.olean", + "sha256": "1f1e99acc389c5ef5818bcc8c7c5e2a2ed0058e0be93661a2b2aaf6c4ccf3220" + }, + "Lean.Server.Completion.CompletionUtils": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionUtils.olean", + "sha256": "1b68673e815b0792013d12790d4bcf8768326df0b7ff0244cf27d3b1fb4603d7" + }, + "Lean.Server.Completion.EligibleHeaderDecls": { + "relative_path": "lib/lean/Lean/Server/Completion/EligibleHeaderDecls.olean", + "sha256": "f71255170c2f18efa266279cda6ec56942e0975689ccd22ec7eaaff127d8433b" + }, + "Lean.Server.Completion.ImportCompletion": { + "relative_path": "lib/lean/Lean/Server/Completion/ImportCompletion.olean", + "sha256": "aed78476c5e3c1d841563b30a1076e4d8392383fc0ba65273f50f96057bb3a5e" + }, + "Lean.Server.Completion.SyntheticCompletion": { + "relative_path": "lib/lean/Lean/Server/Completion/SyntheticCompletion.olean", + "sha256": "6d1733deb5c375a5d09f69a8719d6f0cd91659aac517071e22d50d8c1072d2ca" + }, + "Lean.Server.FileSource": { + "relative_path": "lib/lean/Lean/Server/FileSource.olean", + "sha256": "e28757c52a99267f3c788a9e83b0d30a1461d4113065f45444269fdf7b18f9ae" + }, + "Lean.Server.FileWorker": { + "relative_path": "lib/lean/Lean/Server/FileWorker.olean", + "sha256": "f6529233eb4cc58fd4ce7426ece4285e7b294fcd924f80e60759a609ce75ab4c" + }, + "Lean.Server.FileWorker.ExampleHover": { + "relative_path": "lib/lean/Lean/Server/FileWorker/ExampleHover.olean", + "sha256": "159199fc8757162b59d3e4882a5adde20b9d30f1e1c2e9d73f2d431d8225f8b2" + }, + "Lean.Server.FileWorker.InlayHints": { + "relative_path": "lib/lean/Lean/Server/FileWorker/InlayHints.olean", + "sha256": "a6a0a9f601e15e5f0a4f1a4c58cccfa47a090ddcea06b087cf4d35f83bc8acb8" + }, + "Lean.Server.FileWorker.RequestHandling": { + "relative_path": "lib/lean/Lean/Server/FileWorker/RequestHandling.olean", + "sha256": "bb4929eaa8e2895d7dede2dfcee916694296993384310e57cb44c2f207c769cb" + }, + "Lean.Server.FileWorker.SemanticHighlighting": { + "relative_path": "lib/lean/Lean/Server/FileWorker/SemanticHighlighting.olean", + "sha256": "18293c05d11ec7a4479e7139013a5da2244e92d2a15f6fe0683f5aa25910839c" + }, + "Lean.Server.FileWorker.SetupFile": { + "relative_path": "lib/lean/Lean/Server/FileWorker/SetupFile.olean", + "sha256": "6aadbc90fb133de6196241264b5e9199eb20873ac28c97fd525020b9d1ff8117" + }, + "Lean.Server.FileWorker.Utils": { + "relative_path": "lib/lean/Lean/Server/FileWorker/Utils.olean", + "sha256": "fb1141d854ddd8285b816247a29f6c73f55bdbb57598d5b23b5689b2dd5bc6b4" + }, + "Lean.Server.FileWorker.WidgetRequests": { + "relative_path": "lib/lean/Lean/Server/FileWorker/WidgetRequests.olean", + "sha256": "b6a3538e82fcf0053a603dd6b89dae5ac056f25833d5af7671d9f5730eccc0be" + }, + "Lean.Server.GoTo": { + "relative_path": "lib/lean/Lean/Server/GoTo.olean", + "sha256": "18aa8fbcc0ca8c945db6e6aa3eed8ed4ca27a7c9e08ba86af3f8be0828608cf4" + }, + "Lean.Server.InfoUtils": { + "relative_path": "lib/lean/Lean/Server/InfoUtils.olean", + "sha256": "77b7e95c6f553154b841639d2aa3bb24346e89434327ddcb557b5982e4de69de" + }, + "Lean.Server.References": { + "relative_path": "lib/lean/Lean/Server/References.olean", + "sha256": "de438915fcb962e19d09bfd1905df6632459853730bf416cbe9c1bcae4fe515f" + }, + "Lean.Server.RequestCancellation": { + "relative_path": "lib/lean/Lean/Server/RequestCancellation.olean", + "sha256": "cd8942ec9337da649a58c9f8ea7f01ecce2383c59e080f22116f48f386be3ee0" + }, + "Lean.Server.Requests": { + "relative_path": "lib/lean/Lean/Server/Requests.olean", + "sha256": "0ae37f883b90fbbbb165411871f2f1bf1cc6f166efca062dd8869f14c845c828" + }, + "Lean.Server.Rpc": { + "relative_path": "lib/lean/Lean/Server/Rpc.olean", + "sha256": "640216f0a569300668056ade5912685e2a0543328feba76d00a752859c3b692d" + }, + "Lean.Server.Rpc.Basic": { + "relative_path": "lib/lean/Lean/Server/Rpc/Basic.olean", + "sha256": "09a13a5b0eb1c751cf1689334e7d858d4db582a65bd458efd638a20153839f73" + }, + "Lean.Server.Rpc.Deriving": { + "relative_path": "lib/lean/Lean/Server/Rpc/Deriving.olean", + "sha256": "398279634e15fa8d0aa9394bc63d5ec59a867598db64d76e4772549ba8d29aec" + }, + "Lean.Server.Rpc.RequestHandling": { + "relative_path": "lib/lean/Lean/Server/Rpc/RequestHandling.olean", + "sha256": "0af5a93b3960757ec7bc913b866e9c8bb12a0d3d966d5701f526174d53342c8e" + }, + "Lean.Server.ServerTask": { + "relative_path": "lib/lean/Lean/Server/ServerTask.olean", + "sha256": "5b6e96d39b1fb04527dfe5efb97b1118c1947d723f31cac6c97f8815ad8624a5" + }, + "Lean.Server.Snapshots": { + "relative_path": "lib/lean/Lean/Server/Snapshots.olean", + "sha256": "0fc97604d59c24d8ee81fd5a63dc5ae1abbdc7f9d88e4cdb15eaaee0d0da0991" + }, + "Lean.Server.Test": { + "relative_path": "lib/lean/Lean/Server/Test.olean", + "sha256": "2afbefa351dbf1bcf23b5bfaad40f909905680ad39e528f867b4c463d3db58b1" + }, + "Lean.Server.Test.Cancel": { + "relative_path": "lib/lean/Lean/Server/Test/Cancel.olean", + "sha256": "f33dbeb8bdf19c481feee5ee16bae1d773e043a294995bd4a11f94f604b8771b" + }, + "Lean.Server.Test.Runner": { + "relative_path": "lib/lean/Lean/Server/Test/Runner.olean", + "sha256": "1c8d1946a902c7331616a9a9f7be3d8db6dd5bbe233698c23150fa37043b147d" + }, + "Lean.Server.Utils": { + "relative_path": "lib/lean/Lean/Server/Utils.olean", + "sha256": "c2a03554a131bed630c8b57d965b78c635062a6ac5d29086d801b76e9c3c1e5e" + }, + "Lean.Server.Watchdog": { + "relative_path": "lib/lean/Lean/Server/Watchdog.olean", + "sha256": "25bdfc1d26766745f8123b35795cf75cc03b3d067d7fa917d746a89972fa1081" + }, + "Lean.Structure": { + "relative_path": "lib/lean/Lean/Structure.olean", + "sha256": "1cce03c390b480c9ccfdc752f482f5772f9e8191a89ac2f92dbb371293edce08" + }, + "Lean.SubExpr": { + "relative_path": "lib/lean/Lean/SubExpr.olean", + "sha256": "56463ec2e047a75bc9582f7cba3698476c0595b80ad936524481c97edc7c57bb" + }, + "Lean.Syntax": { + "relative_path": "lib/lean/Lean/Syntax.olean", + "sha256": "1257d7730ef2a59134c6d3a66b812bd28464a93e906d80aa684118a2a2f7e41c" + }, + "Lean.ToExpr": { + "relative_path": "lib/lean/Lean/ToExpr.olean", + "sha256": "681106024aa58dff7c5dbea53ef9b5e01c166267413e6603fb59f7e6ba4705e4" + }, + "Lean.ToLevel": { + "relative_path": "lib/lean/Lean/ToLevel.olean", + "sha256": "0f1039c2e1e3a4e024294fe8827de0b83809ef22d6f95141a20f17bfd57010ed" + }, + "Lean.Util": { + "relative_path": "lib/lean/Lean/Util.olean", + "sha256": "b3804c0b6fd4187caaa395cdbf07b210634c36b5862e5b01e99a334894041ac5" + }, + "Lean.Util.CollectAxioms": { + "relative_path": "lib/lean/Lean/Util/CollectAxioms.olean", + "sha256": "9dd674224d00ea6e9044e05e9022d0997ed842b0eceee5157da199ea523614d3" + }, + "Lean.Util.CollectFVars": { + "relative_path": "lib/lean/Lean/Util/CollectFVars.olean", + "sha256": "03e91ed3ea63c86fa4a74f01eb026cba7a3c7a9a66e911f3420388bf0a24b06a" + }, + "Lean.Util.CollectLevelMVars": { + "relative_path": "lib/lean/Lean/Util/CollectLevelMVars.olean", + "sha256": "ee4f7731ff6e32e49c472ecc660fe70b7e8e28a9fe3e787d95968fc334cdafb9" + }, + "Lean.Util.CollectLevelParams": { + "relative_path": "lib/lean/Lean/Util/CollectLevelParams.olean", + "sha256": "f57df1551f35babfbd25cd4d786d36ca1c1e668a7dc733f1e86a7768a898c70e" + }, + "Lean.Util.CollectMVars": { + "relative_path": "lib/lean/Lean/Util/CollectMVars.olean", + "sha256": "1c5fc9f6e4a37382985419959a6a9e223763b770d78238e26e3b2029565d201e" + }, + "Lean.Util.Diff": { + "relative_path": "lib/lean/Lean/Util/Diff.olean", + "sha256": "348b407f6ab6b4cea1c17189e88ad4449669db50724e85bf333a7cd6eef01f8f" + }, + "Lean.Util.FVarSubset": { + "relative_path": "lib/lean/Lean/Util/FVarSubset.olean", + "sha256": "931302f6ee0fa3706536bf4c786d63c55903ee608fcfee3a7e62a884230b4689" + }, + "Lean.Util.FileSetupInfo": { + "relative_path": "lib/lean/Lean/Util/FileSetupInfo.olean", + "sha256": "fedeae0565096639cc7344c39c75dcd51760d451cf9e3bae3f67403fa3301420" + }, + "Lean.Util.FindExpr": { + "relative_path": "lib/lean/Lean/Util/FindExpr.olean", + "sha256": "fc9f82a261866735ac5f16c64903d5cd7ce354a5d559359f69e14c066299b82a" + }, + "Lean.Util.FindLevelMVar": { + "relative_path": "lib/lean/Lean/Util/FindLevelMVar.olean", + "sha256": "efa86d730a224bac9f9559414945fb8e4480adf9bd5c6f614bc386ccef4b79a8" + }, + "Lean.Util.FindMVar": { + "relative_path": "lib/lean/Lean/Util/FindMVar.olean", + "sha256": "f7c599d6b22db24fed3d4572b254ef1f625abbf242dc21a376a123913fbeaadd" + }, + "Lean.Util.FoldConsts": { + "relative_path": "lib/lean/Lean/Util/FoldConsts.olean", + "sha256": "30a5b555e3da24c6138cda39b0ce2fdd2898549424f3f48a5f0ad5a84a6ad024" + }, + "Lean.Util.ForEachExpr": { + "relative_path": "lib/lean/Lean/Util/ForEachExpr.olean", + "sha256": "f9b3a9c2bd938afe1ed5bfe2cdaac38da291c1f9cbc3ef00c6d70fe18c48b38c" + }, + "Lean.Util.ForEachExprWhere": { + "relative_path": "lib/lean/Lean/Util/ForEachExprWhere.olean", + "sha256": "0f66cc8ae514f42e32e37450023f5325c013a5f3b31cc00643b305ec2050a813" + }, + "Lean.Util.HasConstCache": { + "relative_path": "lib/lean/Lean/Util/HasConstCache.olean", + "sha256": "997838afe6cdc2068b866980bbc2d9571e08821ec262b3f96b5d182bda4d1e41" + }, + "Lean.Util.Heartbeats": { + "relative_path": "lib/lean/Lean/Util/Heartbeats.olean", + "sha256": "ef98dc435a31b539200931e89b2d3f08bd6e7f689e00ec3522ab1210b86e672d" + }, + "Lean.Util.InstantiateLevelParams": { + "relative_path": "lib/lean/Lean/Util/InstantiateLevelParams.olean", + "sha256": "f05e8a234de5794988814cab37b89a021d6e869311cd4fa372ab4f9ee2124424" + }, + "Lean.Util.LakePath": { + "relative_path": "lib/lean/Lean/Util/LakePath.olean", + "sha256": "dd00ea5edef5aeaf9d68948e3616d4de5052a4ac3e2acb67126898567f3fdb1b" + }, + "Lean.Util.LeanOptions": { + "relative_path": "lib/lean/Lean/Util/LeanOptions.olean", + "sha256": "036d4d32660acc69d0fc60938f15ea9ffa1edc7440340197d5d09dfbf7482e02" + }, + "Lean.Util.MonadBacktrack": { + "relative_path": "lib/lean/Lean/Util/MonadBacktrack.olean", + "sha256": "3a721336f768b1bd3d838101868b17bdcddb936acbe232601080cb47dae6bdef" + }, + "Lean.Util.MonadCache": { + "relative_path": "lib/lean/Lean/Util/MonadCache.olean", + "sha256": "a49bf6318c1fa4b7642ee350d0a0adfd5c9c30edfdbf5375bb08c27e89b9d09e" + }, + "Lean.Util.NumApps": { + "relative_path": "lib/lean/Lean/Util/NumApps.olean", + "sha256": "5e9a3b8f61219d6eb81d5e68ebf9783b3e653e6d2cad90d35d7fa1edaf48498d" + }, + "Lean.Util.NumObjs": { + "relative_path": "lib/lean/Lean/Util/NumObjs.olean", + "sha256": "1b6dcd0400b21b6478e0690faf12be333ac561dee8edf34fa9d940e0536d9c8d" + }, + "Lean.Util.OccursCheck": { + "relative_path": "lib/lean/Lean/Util/OccursCheck.olean", + "sha256": "2105d2cafdc97780ed80d0c21d96e3a96eb8c5b27c6f478ad8f511ff1d307a39" + }, + "Lean.Util.PPExt": { + "relative_path": "lib/lean/Lean/Util/PPExt.olean", + "sha256": "a5c502d22177658a419a532038b821f28cef4fa7a32e3c2544726ddd0b019c5e" + }, + "Lean.Util.Path": { + "relative_path": "lib/lean/Lean/Util/Path.olean", + "sha256": "75e708dc5859e0639e7eceae77d508a187db39ccb6cab080143e8dd26d4a0304" + }, + "Lean.Util.Paths": { + "relative_path": "lib/lean/Lean/Util/Paths.olean", + "sha256": "74142ed1f2181bb4102c8a0f6e41d41a4c658232937fc597f4e4b1c2a183b1bc" + }, + "Lean.Util.Profile": { + "relative_path": "lib/lean/Lean/Util/Profile.olean", + "sha256": "f23c4842d954d119e83de4dde14edb34981d6994cbeea4de9c2ae381f17bf831" + }, + "Lean.Util.Profiler": { + "relative_path": "lib/lean/Lean/Util/Profiler.olean", + "sha256": "1e9a3eec7c150b0e9ca1c785861eabb3f9a9c35a00d105c513439ec840a7ccbc" + }, + "Lean.Util.PtrSet": { + "relative_path": "lib/lean/Lean/Util/PtrSet.olean", + "sha256": "231e789db2045483e7600fec9903afba50dbba3e95c8c925982e2c1ea71b8a17" + }, + "Lean.Util.RecDepth": { + "relative_path": "lib/lean/Lean/Util/RecDepth.olean", + "sha256": "ea7a31d5424201f52482f7a9bf6de3ed5e0f8e741c131b78551fc6ac47b6b357" + }, + "Lean.Util.Recognizers": { + "relative_path": "lib/lean/Lean/Util/Recognizers.olean", + "sha256": "6ce3043ebd4aeb4bf7e43914580fc3fc414635d908d152ac393c283e07d0c2ce" + }, + "Lean.Util.ReplaceExpr": { + "relative_path": "lib/lean/Lean/Util/ReplaceExpr.olean", + "sha256": "aee2465ad5bf2bba0f52b8a4ea4b444990bcf68e15c7e32c387f31fb5a4606ec" + }, + "Lean.Util.ReplaceLevel": { + "relative_path": "lib/lean/Lean/Util/ReplaceLevel.olean", + "sha256": "bbdf8e6a5aa715de21a3edea51c9e0798e40fdffbd4896d15a3202d19e21bc21" + }, + "Lean.Util.SCC": { + "relative_path": "lib/lean/Lean/Util/SCC.olean", + "sha256": "f4ecd7303b846253b6aa74f4910f1c97089995e20ea654d78572898ea5ab764a" + }, + "Lean.Util.SafeExponentiation": { + "relative_path": "lib/lean/Lean/Util/SafeExponentiation.olean", + "sha256": "6ac2c719d74ffd8ec932fed7ea38541bb0bd64b1db68c15e143f1b31b7905a03" + }, + "Lean.Util.SearchPath": { + "relative_path": "lib/lean/Lean/Util/SearchPath.olean", + "sha256": "5c541f16a00ce65845346ff39f3e52602ba24873f9143b696ad31a35d0d0b174" + }, + "Lean.Util.ShareCommon": { + "relative_path": "lib/lean/Lean/Util/ShareCommon.olean", + "sha256": "041136336e252a66b1e09dbb0509423603f964469b9f41f34bb45cb47319683a" + }, + "Lean.Util.Sorry": { + "relative_path": "lib/lean/Lean/Util/Sorry.olean", + "sha256": "dc16c4717cb1b982328f48069d111d46ec937d63bf7648c94811c2ac7f8978a5" + }, + "Lean.Util.SortExprs": { + "relative_path": "lib/lean/Lean/Util/SortExprs.olean", + "sha256": "45a472f4dab7a0b1a22a2d5b07eac4e460c7a4471d49646f62e2d97d920faf6e" + }, + "Lean.Util.TestExtern": { + "relative_path": "lib/lean/Lean/Util/TestExtern.olean", + "sha256": "0c45aa686987702907d541dbe624dfb3b8c8389586d732fa05c9b86a53a96800" + }, + "Lean.Util.Trace": { + "relative_path": "lib/lean/Lean/Util/Trace.olean", + "sha256": "40e261ba920c89ca7a7573bfc699a3ac1e20983625025e2fc77a3aa8181a2c8f" + }, + "Lean.Widget": { + "relative_path": "lib/lean/Lean/Widget.olean", + "sha256": "82d3aaf72aaee748640ab3d5857f71623623455d4b4c7ac359f0f4e5e39a49f9" + }, + "Lean.Widget.Basic": { + "relative_path": "lib/lean/Lean/Widget/Basic.olean", + "sha256": "7b47ae225c065d669da84ca522e2dceb9a577e4bd7474d7377cf94d189a14ed9" + }, + "Lean.Widget.Diff": { + "relative_path": "lib/lean/Lean/Widget/Diff.olean", + "sha256": "6803e1c1d4d7de80fabd38cce68ecdabef3888f104d5b5bb17456a41a103ed6f" + }, + "Lean.Widget.InteractiveCode": { + "relative_path": "lib/lean/Lean/Widget/InteractiveCode.olean", + "sha256": "08dd8d5166eba1216188ec5a5b791c2e571805398fad6a4f0d1793026f063f54" + }, + "Lean.Widget.InteractiveDiagnostic": { + "relative_path": "lib/lean/Lean/Widget/InteractiveDiagnostic.olean", + "sha256": "a57b624487c0509b52919bf93ca49fd5006669cd87a28d7d1d6df05b7c121368" + }, + "Lean.Widget.InteractiveGoal": { + "relative_path": "lib/lean/Lean/Widget/InteractiveGoal.olean", + "sha256": "fe6f3299cefd00d81053c19c7a68a9140dd3c1199581807d18bc10212836b5b1" + }, + "Lean.Widget.TaggedText": { + "relative_path": "lib/lean/Lean/Widget/TaggedText.olean", + "sha256": "2231b307e81af9a860c445c61019110b50b2f7a147b20d4eff3a7aca896a495e" + }, + "Lean.Widget.Types": { + "relative_path": "lib/lean/Lean/Widget/Types.olean", + "sha256": "ec95be52006e362cdbab66493e159108d6b2803f7febb6f763d3e6ab58350a40" + }, + "Lean.Widget.UserWidget": { + "relative_path": "lib/lean/Lean/Widget/UserWidget.olean", + "sha256": "0e76215569ef9ba42148916c778a855b0eda47c384ffe95f40848401d3f7e77a" + }, + "Std": { + "relative_path": "lib/lean/Std.olean", + "sha256": "7d3771da25b893da62564bf8198487ff28f01af5cbd410be88d493a4921b2bb1" + }, + "Std.Classes.Ord": { + "relative_path": "lib/lean/Std/Classes/Ord.olean", + "sha256": "d951a4e6a043afe223eec3c1fc4ac05f4da95e923d7f9fa7438ccf1c4c5894e9" + }, + "Std.Data": { + "relative_path": "lib/lean/Std/Data.olean", + "sha256": "0c7214cfc515a6bd7d993a5a036a749d927911c61074e6f000b2f6e5c5e68437" + }, + "Std.Data.DHashMap": { + "relative_path": "lib/lean/Std/Data/DHashMap.olean", + "sha256": "82829a319d1dbc479d69cbeded2541fb6d4bea621843bcfb621dcddf66e3df4a" + }, + "Std.Data.DHashMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/DHashMap/AdditionalOperations.olean", + "sha256": "dcda48b215964eeb7adfdd6d8c898750cfdde669285b7e53559e844747be2e4f" + }, + "Std.Data.DHashMap.Basic": { + "relative_path": "lib/lean/Std/Data/DHashMap/Basic.olean", + "sha256": "3edd8593c538aa619f7a6a49b1201f895b2e195732067e9804cd1ec746ae0230" + }, + "Std.Data.DHashMap.Internal.AssocList.Basic": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Basic.olean", + "sha256": "cde6580d4017820217ba306c2850560e6c3820a22675b795bab7deee58fae39a" + }, + "Std.Data.DHashMap.Internal.AssocList.Lemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.olean", + "sha256": "89bb1625f83532972c2508e241727bd158ed8630437449d6dfb2409004029cca" + }, + "Std.Data.DHashMap.Internal.Defs": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Defs.olean", + "sha256": "b6789918a75b94e20a471fc1249196389b61a7bca005cb6e11868b9b2e0b2050" + }, + "Std.Data.DHashMap.Internal.HashesTo": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/HashesTo.olean", + "sha256": "df5a76c22a9d30d6067466a54454ffafb1d7a268ff2327e10d274d4b86bcb787" + }, + "Std.Data.DHashMap.Internal.Index": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Index.olean", + "sha256": "ca4d3761d5291eccc1f8238dafbe210fa5666c54a0a42c3e9b51acdcbe9d4900" + }, + "Std.Data.DHashMap.Internal.Model": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Model.olean", + "sha256": "dd3b5266f90bdc5e4cc8c5e9c1b65222671aaa830a5a23508f9fdb00fa6111c3" + }, + "Std.Data.DHashMap.Internal.Raw": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Raw.olean", + "sha256": "ab20c7d8f702c86de6cce3e18141f1297dea8d51a579460b0ddab9e278daf908" + }, + "Std.Data.DHashMap.Internal.RawLemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/RawLemmas.olean", + "sha256": "aa891b7b6476ead8295065dcd7df85e16c40e95a8a48c433d1e0c6ff8f58e9a7" + }, + "Std.Data.DHashMap.Internal.WF": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/WF.olean", + "sha256": "0d02c631912fd443890dd882c9035af450a64ded829c5613e29c6ad6d8690538" + }, + "Std.Data.DHashMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Lemmas.olean", + "sha256": "f5191f02349eb72c1ddb45074f9239912d9cd008a48a6cbabd76b2469d28d197" + }, + "Std.Data.DHashMap.Raw": { + "relative_path": "lib/lean/Std/Data/DHashMap/Raw.olean", + "sha256": "5ff8a7568a967e563bba428926cc128806c61ef2ecce021358984a45cff4c308" + }, + "Std.Data.DHashMap.RawDef": { + "relative_path": "lib/lean/Std/Data/DHashMap/RawDef.olean", + "sha256": "98e9e12f08790541143b32cfdaec3d0289209b1e770774dc01345116a7dddca4" + }, + "Std.Data.DHashMap.RawLemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/RawLemmas.olean", + "sha256": "514c964fac6f063724169db30add357a674ca243957dfa221e30430c26f06c92" + }, + "Std.Data.DTreeMap": { + "relative_path": "lib/lean/Std/Data/DTreeMap.olean", + "sha256": "51e3386cf7ba0a9f270c3a6d44af2ef5f6bac8fcffe8458cb7d3bba2edf610aa" + }, + "Std.Data.DTreeMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/DTreeMap/AdditionalOperations.olean", + "sha256": "a20b5c57a0db704748a2e2926dfa4d2cf1e4ddaefcc2245688970941c5ca8429" + }, + "Std.Data.DTreeMap.Basic": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Basic.olean", + "sha256": "26808eeb3d7d1e129af3a70fe13001b79dc74b18c7b406cb1373c7de98f62f56" + }, + "Std.Data.DTreeMap.Internal.Balanced": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Balanced.olean", + "sha256": "485264c582ccaaf76b6796dd881ccd1f6f61012f5d0c722fde5bd9a7b4310c70" + }, + "Std.Data.DTreeMap.Internal.Balancing": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Balancing.olean", + "sha256": "5263f1223026803115af0abbeeffdea7754796f215e6713aefc40c839b8353c1" + }, + "Std.Data.DTreeMap.Internal.Cell": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Cell.olean", + "sha256": "16fadb10f9bf8b6f4f20ec627775bdb827ff1f12c66b8e5f97c7e14b4a63ce98" + }, + "Std.Data.DTreeMap.Internal.Def": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Def.olean", + "sha256": "ad1d1e858fb304c03404a3003afefa2ab63634f240352448dbbe000fbc280ae7" + }, + "Std.Data.DTreeMap.Internal.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Lemmas.olean", + "sha256": "86f93dba7c263b8817d9a6e568d2a298b223b1dcf7a3bf63a21e04485d1e702e" + }, + "Std.Data.DTreeMap.Internal.Model": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Model.olean", + "sha256": "190a424ea72373859e33b93057f74fddfff1901c99020758c3b2a071893edcca" + }, + "Std.Data.DTreeMap.Internal.Operations": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Operations.olean", + "sha256": "02e3f14395f2e036d817076b3e901b7d186bd39c8b9e7204a1684faac1b5eaca" + }, + "Std.Data.DTreeMap.Internal.Ordered": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Ordered.olean", + "sha256": "bfd736cf4717c6dfd91e4764c030a2e35d7d80f24532ceccbb56924be30d3603" + }, + "Std.Data.DTreeMap.Internal.Queries": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Queries.olean", + "sha256": "4fb2bc063203c87f9db29252321a80602d0a7265647778abc9d22aaba5acbee7" + }, + "Std.Data.DTreeMap.Internal.WF.Defs": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Defs.olean", + "sha256": "899b439766bf2c13fba7b5ebfa6da9110b2e9f6e9ad9125c721d339332792432" + }, + "Std.Data.DTreeMap.Internal.WF.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.olean", + "sha256": "b6660199d8eaf0aaa0227cc92ef439c43914ff5f193983cb236d761212481a2a" + }, + "Std.Data.DTreeMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Lemmas.olean", + "sha256": "8f13b8ea4484f0112ac26021f999437da815203047e8d6dd398b3460616466bb" + }, + "Std.Data.DTreeMap.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Raw/Basic.olean", + "sha256": "d7ac0f19bdbd8fc3fbdeb86e07d5359234da8e0ead67247fb552613579747f6c" + }, + "Std.Data.HashMap": { + "relative_path": "lib/lean/Std/Data/HashMap.olean", + "sha256": "99aff9518169b47e1e93af220fb0526ff2a5ecaf538ff1bdd2962b6f2c8d4758" + }, + "Std.Data.HashMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/HashMap/AdditionalOperations.olean", + "sha256": "f7122016e852683cbe4b78252a5a0d334e31d8c583634068600988194a135753" + }, + "Std.Data.HashMap.Basic": { + "relative_path": "lib/lean/Std/Data/HashMap/Basic.olean", + "sha256": "6f76031eeeaa6d43db6e9c3a77c12f7811a80ac7d92b1538bd1b03c99e0588f6" + }, + "Std.Data.HashMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/HashMap/Lemmas.olean", + "sha256": "13da5f44c528a875968ebcab85fafb5cfc854b7f54fd4880ae6fbec2c8dd70d6" + }, + "Std.Data.HashMap.Raw": { + "relative_path": "lib/lean/Std/Data/HashMap/Raw.olean", + "sha256": "e22fdbb83c3274c85d0a292a3810c6408d134cf0d5e8bc0329f50777aee3e3f3" + }, + "Std.Data.HashMap.RawLemmas": { + "relative_path": "lib/lean/Std/Data/HashMap/RawLemmas.olean", + "sha256": "0a3c4d3b8e8d5ab3006148f6e227e5482da7199f8865c0c8dc762d07a13c71a8" + }, + "Std.Data.HashSet": { + "relative_path": "lib/lean/Std/Data/HashSet.olean", + "sha256": "ae45358a15acbf4ac5609305ab80d9ca42fa22cb4589f3c48c2a94a507250451" + }, + "Std.Data.HashSet.Basic": { + "relative_path": "lib/lean/Std/Data/HashSet/Basic.olean", + "sha256": "8bae54c3695a9aa1f51b76043d32ebbae9123b1a155605c54c1be2a899ce3385" + }, + "Std.Data.HashSet.Lemmas": { + "relative_path": "lib/lean/Std/Data/HashSet/Lemmas.olean", + "sha256": "29883ee4a5a8aceeef42dd000f1a3d682416b3668289b05afbb86cf3dbe7ed72" + }, + "Std.Data.HashSet.Raw": { + "relative_path": "lib/lean/Std/Data/HashSet/Raw.olean", + "sha256": "dc892a38a4976c064458b561027640cb3343c9661141c532c465f24bb635271d" + }, + "Std.Data.HashSet.RawLemmas": { + "relative_path": "lib/lean/Std/Data/HashSet/RawLemmas.olean", + "sha256": "ad52a319fb705c08ffd691126d42ee63e0e6a6caeb828114828cc2fe466f8db9" + }, + "Std.Data.Internal.Cut": { + "relative_path": "lib/lean/Std/Data/Internal/Cut.olean", + "sha256": "16e746f9da7b0e74567b1656a7e3f99cafc699acc54faed11bbe17a02d801060" + }, + "Std.Data.Internal.List.Associative": { + "relative_path": "lib/lean/Std/Data/Internal/List/Associative.olean", + "sha256": "fec662ce7c583a3d835d612b39ec478a6153c06e3b7de30a537cf6895f5bb093" + }, + "Std.Data.Internal.List.Defs": { + "relative_path": "lib/lean/Std/Data/Internal/List/Defs.olean", + "sha256": "56e8ec040898820fa1f1b9d807be6c96e4c44812b61c37b29ba4eb92199dbbc4" + }, + "Std.Data.TreeMap": { + "relative_path": "lib/lean/Std/Data/TreeMap.olean", + "sha256": "a1acd79ea550bcbeb8803a663d203d65c2ec5f3c528e1d3b20e6d84bba1f5818" + }, + "Std.Data.TreeMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/TreeMap/AdditionalOperations.olean", + "sha256": "7ff677628c427286ffa273bb5e733ba2b3c400ba4ac199377d8f354740bd90d5" + }, + "Std.Data.TreeMap.Basic": { + "relative_path": "lib/lean/Std/Data/TreeMap/Basic.olean", + "sha256": "01d1578d10e52b69cfa9a2ebc0dbbb16dd36a786deee2bdf44129b2672f67755" + }, + "Std.Data.TreeMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/TreeMap/Lemmas.olean", + "sha256": "c6b1f9d219326bf24700910e14066001120a278f007001bbf2a32dedd1af4006" + }, + "Std.Data.TreeMap.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/TreeMap/Raw/Basic.olean", + "sha256": "bc2fb5d7aa288ceb2d373f3c6a66c016a439cd1eb5560ba2a641e835064c833e" + }, + "Std.Data.TreeSet": { + "relative_path": "lib/lean/Std/Data/TreeSet.olean", + "sha256": "14078e4b78360b5431a4232dc911486455591bff1a3fad55f9155ae8c2ad7cac" + }, + "Std.Data.TreeSet.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/TreeSet/AdditionalOperations.olean", + "sha256": "86a8774587ec420050092ce6ba115aa9d379c59b491f55c815c062fdff15ce73" + }, + "Std.Data.TreeSet.Basic": { + "relative_path": "lib/lean/Std/Data/TreeSet/Basic.olean", + "sha256": "8f725039367c3acfe7a9de41011ce1bf66cb375fb16a0b4468d414c2f0ed5fc6" + }, + "Std.Data.TreeSet.Lemmas": { + "relative_path": "lib/lean/Std/Data/TreeSet/Lemmas.olean", + "sha256": "c436c982509e245de849ae7ca0a437b7f08eed26cd7a3eccc926763acd3fe9fe" + }, + "Std.Data.TreeSet.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/TreeSet/Raw/Basic.olean", + "sha256": "e970f9894439ef66418424f9d769c9e76de5ed0a6443c90dd821b482d715d015" + }, + "Std.Internal": { + "relative_path": "lib/lean/Std/Internal.olean", + "sha256": "450df0e4fd6e36bd632bccad2663e04b615dbba865e59de53815dd54bc5d3c1f" + }, + "Std.Internal.Async": { + "relative_path": "lib/lean/Std/Internal/Async.olean", + "sha256": "01ffdfd1f0410911338f8ef8b7e5f403d875b1a38ed01eac1953cd9c1659e3eb" + }, + "Std.Internal.Async.Basic": { + "relative_path": "lib/lean/Std/Internal/Async/Basic.olean", + "sha256": "77e5e714a1a50a1c66d738574d61b94729fa505d928f4041b479220c35f926d2" + }, + "Std.Internal.Async.TCP": { + "relative_path": "lib/lean/Std/Internal/Async/TCP.olean", + "sha256": "b8d4d89acab2bbb45c8f0ae41f0d43a9d1978efdbbf3cce9d21a8adbe977fbf2" + }, + "Std.Internal.Async.Timer": { + "relative_path": "lib/lean/Std/Internal/Async/Timer.olean", + "sha256": "df2a28402222a5529fe6c5d506b96d8b1a11a9a5722456590e77be97fe7bd59f" + }, + "Std.Internal.Async.UDP": { + "relative_path": "lib/lean/Std/Internal/Async/UDP.olean", + "sha256": "42aaaef54fd0324c3160d18901df6ab67d12c1392a5f7f79764e4b8ccdabef84" + }, + "Std.Internal.Parsec": { + "relative_path": "lib/lean/Std/Internal/Parsec.olean", + "sha256": "847cdbecf06faf5fc1ec0a8edbda87e56cae864215c3e5b0794e4487e52991e5" + }, + "Std.Internal.Parsec.Basic": { + "relative_path": "lib/lean/Std/Internal/Parsec/Basic.olean", + "sha256": "5043a60429010c81f150397f937633e38e59a4ebb0fedd362a3c4326d4c9e70c" + }, + "Std.Internal.Parsec.ByteArray": { + "relative_path": "lib/lean/Std/Internal/Parsec/ByteArray.olean", + "sha256": "b83f1320328c2ad431534ac41512842f4d99059c8ffce50cfad5c323f5d05bcb" + }, + "Std.Internal.Parsec.String": { + "relative_path": "lib/lean/Std/Internal/Parsec/String.olean", + "sha256": "d8fb53b268a2d7ca6b26a14028a6e2a396063d3c747373aca64f18bdafbcdd82" + }, + "Std.Internal.Rat": { + "relative_path": "lib/lean/Std/Internal/Rat.olean", + "sha256": "63e1219fe06b26b0022abcebc49b641a8726d1ffcb43650b6afcb61af71ef85e" + }, + "Std.Internal.UV": { + "relative_path": "lib/lean/Std/Internal/UV.olean", + "sha256": "510f7cfab3bf9547fe3bce0dd31453b8521ed3b7b25beeb16ee88bb088c90e60" + }, + "Std.Internal.UV.Loop": { + "relative_path": "lib/lean/Std/Internal/UV/Loop.olean", + "sha256": "732dc39b26fbc6027819191475f9aade211b5995be9036bf0babd80d2740d09e" + }, + "Std.Internal.UV.TCP": { + "relative_path": "lib/lean/Std/Internal/UV/TCP.olean", + "sha256": "dadd785a07060659ba22f37fcb6e17a06af3b6140d200e7d8f223ae7aaf928ad" + }, + "Std.Internal.UV.Timer": { + "relative_path": "lib/lean/Std/Internal/UV/Timer.olean", + "sha256": "57cee1e20bf5d037bcf6afe9720488ee00720e2deb2ce05d0445d4e097fc27b1" + }, + "Std.Internal.UV.UDP": { + "relative_path": "lib/lean/Std/Internal/UV/UDP.olean", + "sha256": "29d41d16510671c81a1df5b46e75f8c61c0ecce2ee5b35e53737bdc724022b2e" + }, + "Std.Net": { + "relative_path": "lib/lean/Std/Net.olean", + "sha256": "4c3e86bee81a4336a0aa64a3be9467a20b8b738bd1a8924ee4df82b980a0e4a2" + }, + "Std.Net.Addr": { + "relative_path": "lib/lean/Std/Net/Addr.olean", + "sha256": "21a68252d88ccc4e33691b2cab7aef5cc7cc8881c4e7a00e2154c4db8635492d" + }, + "Std.Sat": { + "relative_path": "lib/lean/Std/Sat.olean", + "sha256": "fcc29fb616396ddc2d3047d9b5c2f8dd3ad6239d727e06edfa2273e11f22109c" + }, + "Std.Sat.AIG": { + "relative_path": "lib/lean/Std/Sat/AIG.olean", + "sha256": "7c6aea2cf4f55d3ea5b3b4ae186869fcd416cb24fc5b1c797bf2aa511ced7207" + }, + "Std.Sat.AIG.Basic": { + "relative_path": "lib/lean/Std/Sat/AIG/Basic.olean", + "sha256": "97590c68ccbef54da03f6ea927368d999b560f594840a2c2c3899e52602a2a19" + }, + "Std.Sat.AIG.CNF": { + "relative_path": "lib/lean/Std/Sat/AIG/CNF.olean", + "sha256": "38e7324f561c93510b5b42466fc3b60be8372a46e0b872a45678fd6dc40c8495" + }, + "Std.Sat.AIG.Cached": { + "relative_path": "lib/lean/Std/Sat/AIG/Cached.olean", + "sha256": "f9b8e7536aaa9f2663fb19cbfddd1da6c0c9d1035b79ed5f71acea3ed76a913f" + }, + "Std.Sat.AIG.CachedGates": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedGates.olean", + "sha256": "a9fba0492584b3e3e537f181e626be94d5ff4d4f7cdfb6193d0ebfa59619fb03" + }, + "Std.Sat.AIG.CachedGatesLemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedGatesLemmas.olean", + "sha256": "e7637f2f0f2df05851138dc94f305c976aca8fbd121f648afae1b1be75edf072" + }, + "Std.Sat.AIG.CachedLemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedLemmas.olean", + "sha256": "4e8c65e9bc960950ea123ee30c9434b1e7a31955db5c6b118b5f6d1bf91b4151" + }, + "Std.Sat.AIG.If": { + "relative_path": "lib/lean/Std/Sat/AIG/If.olean", + "sha256": "0a976606263c24d96f678d34322b1172ee3ae1c1f50c9bc25274411b99ddbb21" + }, + "Std.Sat.AIG.LawfulOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/LawfulOperator.olean", + "sha256": "c8467c1aee8523a9b728ccf79988145304cada06f1da7eb80324db331aec8728" + }, + "Std.Sat.AIG.LawfulVecOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/LawfulVecOperator.olean", + "sha256": "2bcfabf0755288b3c3099a16e615e0e7e474c9b48e705ebee28137a46c4c6768" + }, + "Std.Sat.AIG.Lemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/Lemmas.olean", + "sha256": "0056f8de120614c48889fe5157b0fa5eb4e5caa87c1300a46d6f412268baf65d" + }, + "Std.Sat.AIG.RefVec": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVec.olean", + "sha256": "e8de7999a97a5390370aec10715a77d3abaf292a7df37a584c06e706458284ae" + }, + "Std.Sat.AIG.RefVecOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator.olean", + "sha256": "c07b62713579424613487ed5f40318b44cd5a30036959d23e9c7a39256c9474f" + }, + "Std.Sat.AIG.RefVecOperator.Fold": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Fold.olean", + "sha256": "8c65d0c2a25e424866314efd53a4edc08c2cd9da55edb76034538969fa3db5bc" + }, + "Std.Sat.AIG.RefVecOperator.Map": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Map.olean", + "sha256": "569cee3ddeb7b1b314354d0f051052bc4d21919d3948c06eeaba5da15f9dac96" + }, + "Std.Sat.AIG.RefVecOperator.Zip": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Zip.olean", + "sha256": "94244a0a8f0ce753f93b64831b56577cd9b8d68f9131b278281b77a3f2d43d44" + }, + "Std.Sat.AIG.Relabel": { + "relative_path": "lib/lean/Std/Sat/AIG/Relabel.olean", + "sha256": "fbdc72b958646b6206f8fd36cac01472e075dc69705f33947bbbef6614b6aa8b" + }, + "Std.Sat.AIG.RelabelNat": { + "relative_path": "lib/lean/Std/Sat/AIG/RelabelNat.olean", + "sha256": "8d7e0ea32786d8ce69c8605df88c666dbf8dee641c7945fde40e302ce7051a9d" + }, + "Std.Sat.CNF": { + "relative_path": "lib/lean/Std/Sat/CNF.olean", + "sha256": "a7ad1ae81e0305e03e2b6f3827101cde4cf4da0b64a59b3a25c038c4661ddc77" + }, + "Std.Sat.CNF.Basic": { + "relative_path": "lib/lean/Std/Sat/CNF/Basic.olean", + "sha256": "9fd3c6545ed9a1cb8b606df1749d7e40eb4eac6932fd19ad0efbbaaef98534d4" + }, + "Std.Sat.CNF.Dimacs": { + "relative_path": "lib/lean/Std/Sat/CNF/Dimacs.olean", + "sha256": "d35723222970cd0c95eccee2d1c8d94aef51ab955c1b8f35eb024fc395f664b4" + }, + "Std.Sat.CNF.Literal": { + "relative_path": "lib/lean/Std/Sat/CNF/Literal.olean", + "sha256": "86f2a80fe2c28b8e831989e13154f772a51fe820bca3ea61c5a542a56b0eef6d" + }, + "Std.Sat.CNF.Relabel": { + "relative_path": "lib/lean/Std/Sat/CNF/Relabel.olean", + "sha256": "e9bb76081b5ecf50ee4b6dd88e99f9cf405dc77574772c8645fd5f43d4310ec3" + }, + "Std.Sat.CNF.RelabelFin": { + "relative_path": "lib/lean/Std/Sat/CNF/RelabelFin.olean", + "sha256": "5b23bd94880be12c59a33437f57c82873234d547a0085a29c6dc4ca37f304ab2" + }, + "Std.Sync": { + "relative_path": "lib/lean/Std/Sync.olean", + "sha256": "6b122caecb73d049b18ea82b184696b04898758dea48f62c7e8b0ec17068c34f" + }, + "Std.Sync.Barrier": { + "relative_path": "lib/lean/Std/Sync/Barrier.olean", + "sha256": "0865e927b2d5c74eb1e762ef6043b19db015a3f7a16997392bdbe3405616c9e6" + }, + "Std.Sync.Basic": { + "relative_path": "lib/lean/Std/Sync/Basic.olean", + "sha256": "0ab37aae226de3c3c249e48eb99348220fd9239db043e8e70b00491ca7df6ffb" + }, + "Std.Sync.Channel": { + "relative_path": "lib/lean/Std/Sync/Channel.olean", + "sha256": "d263a7b5e81f7d062701d56c2f2940ec728e0b45d42ae29ac7ef5ad174b17a0f" + }, + "Std.Sync.Mutex": { + "relative_path": "lib/lean/Std/Sync/Mutex.olean", + "sha256": "28b1da9b8ad2e7873573ef3a394c20fbb1483b145dea927e22ae760913dfd30c" + }, + "Std.Sync.RecursiveMutex": { + "relative_path": "lib/lean/Std/Sync/RecursiveMutex.olean", + "sha256": "e270bb327da588a077b986c6683149f93c99ed2e43f2b80cdc79bf3255118fe5" + }, + "Std.Tactic": { + "relative_path": "lib/lean/Std/Tactic.olean", + "sha256": "bc4cb70f826910d0d63d5bb519966d715681e8fe8fb73913796d9c51c8530d7d" + }, + "Std.Tactic.BVDecide": { + "relative_path": "lib/lean/Std/Tactic/BVDecide.olean", + "sha256": "ec2db6253a2c5adbe13b53fdf97893e62022706a3a1604ade21af796ae949a17" + }, + "Std.Tactic.BVDecide.Bitblast": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast.olean", + "sha256": "faef1612ce3f38d3fa7978cf6b303d9876bbd43837dab7bfc0d7df30a42a1f86" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.olean", + "sha256": "36c4f0fd074cd62290da4cd5d0dd25b253108e7b37927836a2a68e24cbc62611" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.olean", + "sha256": "3fbf55b92e7fa7459b5626803a5c28693f10ae22bcc07dd0bbd5f9e52ddd5fc4" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.olean", + "sha256": "dc870f512d9db277c5e04837974578471b7aa8b6d7cd20c2e349c9f55776fde1" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.olean", + "sha256": "2bc70c17d6a23ed6d2b67e0fa0c46a2cde4b41fa6aec824dc64f609a81f8076b" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.olean", + "sha256": "28690113394104f6b0bf446e71254522b38e370ad8b4c48d2643c3c251f117c4" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.olean", + "sha256": "f831b1544b66b6c04562548d8ee3cd406faed9171e989001d235ca22489d93de" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.olean", + "sha256": "00399f76c92cefb3439614ef294998f337e72995b6279c7f3f57be5a182f3952" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.olean", + "sha256": "9fc172f017a8e08b3d373edb60be3aba9e3d82854acee27bb757e2052b7a073f" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.olean", + "sha256": "ba59db26788faeb05b026dd06ba5ddb8b39cb9169110413fa6ad5d65a1782f43" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.olean", + "sha256": "296f54c53ddf18f21dd6dbc6e279ba7256b944e35ed130570288d2fbc1bbafd3" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.olean", + "sha256": "4391a259589f6be7008648b4ab9eef743dc2b9a74f0f7dd4d631d534b8811e17" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.olean", + "sha256": "c87ee1a5d918eeda72930bbcf4889d9402a09bfe286b25012b06efac778dafbf" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.olean", + "sha256": "69116d9ffc41a4f37932d8cb3b4cea6592b9bda6f583df045b0f30ae0ec4a878" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.olean", + "sha256": "1c3439af37c32110c822bfee7afdf8b82289219f223e4475a61a2930876c270d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.olean", + "sha256": "bdae571ecb63fcd2e404c549d0233645f1d49daa257b854c03fdc672b11f25fe" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.olean", + "sha256": "6be36fe5e846df460b9cafdce7ce00525a16032b0f9957ef269429e4bc3235ce" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.olean", + "sha256": "2af3d46c89c1184b87d0499f08ae1364ede6b4d45a682ecc84a646c6ff37b590" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.olean", + "sha256": "59df5f0bdf0ab63f1d3a70c1ec428b51cd4d272aedd17ff6e69a47c8043eeb90" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.olean", + "sha256": "1c55bdc3550f4476aad8e2aabd64211d69c8993514758e2af3cc2251769b138e" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.olean", + "sha256": "f13b326a06e1000c0515520d0f4899e1aff23420f0e0e6ac5bba48a7a2061741" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.olean", + "sha256": "102946d64852967c3f451a662c10e0a548bec046e621e551b7dc467e4a0a2d7e" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.olean", + "sha256": "5f58293f58319935148d7a2bc68ad221ce9f5af0083862d72aece51381358100" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.olean", + "sha256": "5d0b577707c12577db272d62533ff29b2c37eca1ea425df4aaf104e74082ce1d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.olean", + "sha256": "0557dd76c0b555d978d97d7f04bc178ebb786d428871e4dd3cd73445f8bd2c39" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.olean", + "sha256": "81ba89dd877e8f5ecb4d79795d720bff671a1c226354759b28fab162f38e46ff" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.olean", + "sha256": "ebc829c16a69ba4601c7173f03eec5532020c0cff7ae92cd6dbcefd0368c2697" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.olean", + "sha256": "a4303ebf7a2e9d22270c2838e6240c06b563518adb9d4137349db1777b96ba86" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.olean", + "sha256": "3a8c2f39f7bf1f389bbd88e0e960d34ecf4b7af474a15d3669a397fe63a3b687" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.olean", + "sha256": "d67ad63ce049fe122cf9772ed2782555c6616ac326f67426e153f6cd5f5f31ea" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.olean", + "sha256": "308ad2bec762bc6ba6dd20c8a59466369dff6f12baed0014502ceb9af81f9128" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.olean", + "sha256": "c594d47b6dd7831dc6fbf18f337e4beb8cc317596d4da513c74cdd590b2aaa82" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.olean", + "sha256": "0e83560f33741e683d83de2c88d3b9bea126b818d4f9b947b6e2e60f3273793a" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.olean", + "sha256": "f4afff7bfa61967afcddcef49102e8aa6abfb46ac719f45fae9b2929995939df" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.olean", + "sha256": "57f9283128ba0708949930c0919ecadc22ec7b9d7e6b2dcdd7fad92a736afe0d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.olean", + "sha256": "35d396442771affa7630a0347396755620f9d042e8d489514dbefa2e5f3bd3ef" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.olean", + "sha256": "61ab83020b62ecea43b39fb36d24b2c6264f101c300bc53a020e29ac5cf23202" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.olean", + "sha256": "561125bbfaf3f343d17e25d37d77e43cfd0eaf6e21e0017cc9112929162d6628" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.olean", + "sha256": "cc8b989993b821ea578bb842b8da6c80522df6826b6d01238ca5adb568e449ac" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.olean", + "sha256": "d3072d202bf75c36371af08a4299d2982ad51392353d92d5011357964e3cd384" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.olean", + "sha256": "2be5439ac28922644312c8f8299059f81e58c79741d3a681a8a14a83457649ab" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.olean", + "sha256": "5b894fa82377d826b231e52d38987bf71fc1b10a92a7955fd18d9e5e5ebfe7ec" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.olean", + "sha256": "b2ac78762a87a6575421fda19f6576adf93e93f0b1af4b0ce49f55b8e9064463" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.olean", + "sha256": "0c5587d74b82923fd948c50d3da937bab12b86ec827d5e560c82b35bfa5c68fa" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.olean", + "sha256": "b95d38b7d0aabf70cb06123400e6ba0b94fd6073228b0eb5f55ab97d4428938a" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.olean", + "sha256": "789048c3011f067a8b8fba24630807fa03ce445f9e3dfac8c3528a4456603265" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.olean", + "sha256": "3dcc31a71f38e23ac8977a6e457302b32f5bcebde968012f3c33719e6b9c14f3" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.olean", + "sha256": "b5f8825d43310fb7f7333af20149f3064337396bafef7011d8af55c7f90380a5" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.olean", + "sha256": "8d9ff31e861a653c4998376235a1bfd1dcf760f05e1500f9867180cefd020d8b" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.olean", + "sha256": "10d1d3835811dde10bb29ad96b6c897780d8560198b0d04f28d1c3e4f4be1205" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.olean", + "sha256": "41ca8e8480c53c66991bf6dd267aa6bcd8d7c347942dec93d11b85f8d7224555" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.olean", + "sha256": "b2d68c645229bcfff4c1cb5d536e6acc7cb924ee954f9632198d5039280cd446" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.olean", + "sha256": "76828daa75f4568048da7ae525f1da9927112b9ea96ec22385387e2dcc0d1cbe" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.olean", + "sha256": "1a87afbf4654899ff46aed23db3f6ee24775b3113f551d4b1fb1e4e055b4968b" + }, + "Std.Tactic.BVDecide.Bitblast.BoolExpr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.olean", + "sha256": "3ab631e587fb4f4a5fc155f91d705d3ac544f98c75b22313db962ae0fcd9ba26" + }, + "Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.olean", + "sha256": "d441ce6550ac5d66fa7fed9d2f1b2e6a7207a0aa82d82da4ea372b2a4fad5526" + }, + "Std.Tactic.BVDecide.LRAT": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT.olean", + "sha256": "d355212d6f59c522d94e3c3dd34e3a02d74584f21270d3c75fd0f7b0fc1e6b23" + }, + "Std.Tactic.BVDecide.LRAT.Actions": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Actions.olean", + "sha256": "0077323c22e78b14dd46684d812da596c363a8f835ab47d9b7b429edcaf77c6f" + }, + "Std.Tactic.BVDecide.LRAT.Checker": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Checker.olean", + "sha256": "24cd2c42a4f2f34ecb83b2214194c9c808c7cc2ae49763f785d66911fb791e64" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Actions": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.olean", + "sha256": "6a8d16b5f258b9da457a8dae2729cf9cc8184ae3770c62c7767b60610d12cbf2" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Assignment": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.olean", + "sha256": "1dc4cf78bf8dd9093f22e8fb31fc2585a676096e1f92d8a169853e8c32e27868" + }, + "Std.Tactic.BVDecide.LRAT.Internal.CNF": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.olean", + "sha256": "5b09536fadc7ad28c0597d86a2926cc69397fbf93011a53ec07f3bc5d8144527" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Clause": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.olean", + "sha256": "c0ee4492b32ab35324ba3aa234288a517bbfd1a057b55a12b5587579dc8de5e4" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Convert": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.olean", + "sha256": "644f9516699727499c6bbf434dc411c7e32be39727c27df9fcf4ac4bc7885dfd" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Entails": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.olean", + "sha256": "555bd01a87e35f742a6784327cb0e15caa4b4589fdcb23b7d156612c8359aa60" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.olean", + "sha256": "e402782d59c498b9098addaf51b65c2a1f76015a3626d11ab150c7f8e4525e3c" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Class": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.olean", + "sha256": "61faf33007eb81ff1ba8c12c4829d6b8353b52580d1ae32216c5acce24117930" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.olean", + "sha256": "d8d956c48977e92718e15f51f3ed0e37b2523e84129f48c93d738a5ecc73e598" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.olean", + "sha256": "02dc2826a248aba00b4ff538bf73d1e84a1d26cb6bd86878e9aeaf96911578ea" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.olean", + "sha256": "326b363db75185b4e385f6d5ed25e3bc52249695cd47e96f7291b2befc17d99d" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.olean", + "sha256": "c8ae044e3f0cbfbdd16a5c8776c5bb505b8edecd7caa7227ac3e268f8e5a813b" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.olean", + "sha256": "f4639e7f4ce1257677cb3ef954622a378c51facaa49d1c2033d655a0429854ee" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.olean", + "sha256": "3db7edc84442cd86d9688f0259a59868e76ed0759f2d86dd35da5b8e928fecb5" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.olean", + "sha256": "7584cffd13ae359e9c7ef8edaea45c6d0233fbdcee5d80ee57aa9ac5284af5ce" + }, + "Std.Tactic.BVDecide.LRAT.Internal.LRATChecker": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.olean", + "sha256": "adad26830176d3fbb2cbd64c83197f5083e196b2a2651ee8d7194512724770da" + }, + "Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.olean", + "sha256": "b21dfacd5f2e5488e49885bfcf7de9deeb429a3c12a9a5d595f9f118372e8f90" + }, + "Std.Tactic.BVDecide.LRAT.Internal.PosFin": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.olean", + "sha256": "c9064ca9acae028a144600c48c49583991419d743274fc91d3bc6033e5f647a5" + }, + "Std.Tactic.BVDecide.LRAT.Parser": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Parser.olean", + "sha256": "99c91ddf2e3209427989057505c6db8ae009b0b66473add1123091e82eae22d5" + }, + "Std.Tactic.BVDecide.Normalize": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize.olean", + "sha256": "5a32966bb5d1d044ebbfa16701971c19613410077471fd78907932d23ac9d896" + }, + "Std.Tactic.BVDecide.Normalize.BitVec": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/BitVec.olean", + "sha256": "9a5419dace60a2336218c9900ccc2ba5b1740ee3ad3395204c1db96e2ee1265a" + }, + "Std.Tactic.BVDecide.Normalize.Bool": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Bool.olean", + "sha256": "e4a7ad5bb1aa46632d4f53c2e534df650adbab5d2299ab05f9357bf814568c02" + }, + "Std.Tactic.BVDecide.Normalize.Canonicalize": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.olean", + "sha256": "42efde7852aa32bfb49a2096a017f1acc3de2be1843f9a766fc33a2e8dba6ec9" + }, + "Std.Tactic.BVDecide.Normalize.Equal": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Equal.olean", + "sha256": "b811a7a95c0f5e441dfc6b4cefb0eec03e237442d2c57224fa4cf498436be742" + }, + "Std.Tactic.BVDecide.Normalize.Prop": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Prop.olean", + "sha256": "299264cac5f784ffcb12d7ec211033cf7913c4470e7ff363ade0cbbd2f18ea9a" + }, + "Std.Tactic.BVDecide.Reflect": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Reflect.olean", + "sha256": "6fa2f9828a59c1674437bee299f112a673ce7a30add77784b2bb610b6fdb50c6" + }, + "Std.Tactic.BVDecide.Syntax": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Syntax.olean", + "sha256": "0359dc3655c79f41a47af4d3c87485f738b79ac032d59738bbf48e16027416ba" + }, + "Std.Time": { + "relative_path": "lib/lean/Std/Time.olean", + "sha256": "0789687baa3558734be38cc4d152d748e9c6d2edf399507a1976246ce1db15d9" + }, + "Std.Time.Date": { + "relative_path": "lib/lean/Std/Time/Date.olean", + "sha256": "cb70aed3ccf7127c906dcab116c95c522aecb3987140814941c84eae42bf3f2a" + }, + "Std.Time.Date.Basic": { + "relative_path": "lib/lean/Std/Time/Date/Basic.olean", + "sha256": "f307e1a552373d28301792b5ca8bd0110b8e9d93eb81575689fbe3efd52b7ed8" + }, + "Std.Time.Date.PlainDate": { + "relative_path": "lib/lean/Std/Time/Date/PlainDate.olean", + "sha256": "9e9df12ccb5c285114cfdcf4039a2a021614747c9c45ccb6995722d248ddf3bb" + }, + "Std.Time.Date.Unit.Basic": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Basic.olean", + "sha256": "a073a7513d6b1fd55d88c56f341a3db71a933ee0563334e869db0e51618648f7" + }, + "Std.Time.Date.Unit.Day": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Day.olean", + "sha256": "5ebf7bb099376860bc2f18e7301dc33b2fba23a8de092dfa4ccc540a607edb1f" + }, + "Std.Time.Date.Unit.Month": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Month.olean", + "sha256": "795840aeee04727bd136c09d6f7c57c5eab32967bc5baa642caa071700d6f5ba" + }, + "Std.Time.Date.Unit.Week": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Week.olean", + "sha256": "1af7b14f7241b1157f7ede0be10b1ce8f84d59629fe9256ef2853f93f9920d10" + }, + "Std.Time.Date.Unit.Weekday": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Weekday.olean", + "sha256": "58a27e1054c0f7083540030928455a2f7f89568fd4df27904a992312e540431a" + }, + "Std.Time.Date.Unit.Year": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Year.olean", + "sha256": "1429b88657ba6078d953466050ae379a2c0ad32f908e64d3791b3f91271ab506" + }, + "Std.Time.Date.ValidDate": { + "relative_path": "lib/lean/Std/Time/Date/ValidDate.olean", + "sha256": "ace3749ecca5141ab1d66312455cbc165abe4a5e2a92e99181bdcab5a45dcaf8" + }, + "Std.Time.DateTime": { + "relative_path": "lib/lean/Std/Time/DateTime.olean", + "sha256": "bace36aa9c50b519ee6e46e6489fdfe349e77b3f7f00e952b8ddc54361639811" + }, + "Std.Time.DateTime.PlainDateTime": { + "relative_path": "lib/lean/Std/Time/DateTime/PlainDateTime.olean", + "sha256": "1296dc0c67ac54dbc5d0b1977fcfff082655daaea079ba088c070cdc4890924c" + }, + "Std.Time.DateTime.Timestamp": { + "relative_path": "lib/lean/Std/Time/DateTime/Timestamp.olean", + "sha256": "b4cd23a2f4ea4c96f2df2b83cfc655d0e19bef0238f6c044bf37b417faeb8756" + }, + "Std.Time.Duration": { + "relative_path": "lib/lean/Std/Time/Duration.olean", + "sha256": "768a81cc06f2a7b70728d660889a4e243f0fcfcf9270cdf735c7f95a26775a81" + }, + "Std.Time.Format": { + "relative_path": "lib/lean/Std/Time/Format.olean", + "sha256": "8d0928fbefb93f6de1f46e7e622f86beadb3e27115a29880eb0745b6fd74b7d4" + }, + "Std.Time.Format.Basic": { + "relative_path": "lib/lean/Std/Time/Format/Basic.olean", + "sha256": "23d409ed591814fd515cfb89781c282bf1990635241a8dac0fe4aa40668ce135" + }, + "Std.Time.Internal": { + "relative_path": "lib/lean/Std/Time/Internal.olean", + "sha256": "aecafe702fdd9d7c770b6b7d4d1843616ed03470014b13ea1ffc0d376c8091f0" + }, + "Std.Time.Internal.Bounded": { + "relative_path": "lib/lean/Std/Time/Internal/Bounded.olean", + "sha256": "49de757e44969f7b58b61b2218ba797db7d82682f64e272a249ffa13cec52d06" + }, + "Std.Time.Internal.UnitVal": { + "relative_path": "lib/lean/Std/Time/Internal/UnitVal.olean", + "sha256": "2293196364e88707f8cb1d82e99a18f155630a82a60f1ea6399f0144fdb6ef3f" + }, + "Std.Time.Notation": { + "relative_path": "lib/lean/Std/Time/Notation.olean", + "sha256": "9e9cd56d4bb18752d074d9a5545677bf880510f07038ad29595c0d88754b21c0" + }, + "Std.Time.Notation.Spec": { + "relative_path": "lib/lean/Std/Time/Notation/Spec.olean", + "sha256": "a08aada50626422dffd9168eccc354a0dda7769fc33d943c48d5c6dbeba380dd" + }, + "Std.Time.Time": { + "relative_path": "lib/lean/Std/Time/Time.olean", + "sha256": "aaa5e2da3807c23c60e80153e6a683af0835a58d89805dfb52cf9cfcdd09599b" + }, + "Std.Time.Time.Basic": { + "relative_path": "lib/lean/Std/Time/Time/Basic.olean", + "sha256": "08e7ff82d05c4f4aa49fc9b0702a1d499f31334df58a4dd693c92cf1860f50e8" + }, + "Std.Time.Time.HourMarker": { + "relative_path": "lib/lean/Std/Time/Time/HourMarker.olean", + "sha256": "be5bbcafbc86d200ae38d3681fa62eb89c5f92e54e658ce926f535a4ea5b7821" + }, + "Std.Time.Time.PlainTime": { + "relative_path": "lib/lean/Std/Time/Time/PlainTime.olean", + "sha256": "c341b0c38877ca56f7b8b758947b2e4cbe2cc5818286d78c4cb7d7f08fe60580" + }, + "Std.Time.Time.Unit.Basic": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Basic.olean", + "sha256": "d9802ce1313c896333ee3ad31889057c81f13bd40510da853d711018eb82deee" + }, + "Std.Time.Time.Unit.Hour": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Hour.olean", + "sha256": "cd26a34fd6964178efcfa29c86f9f240bb61dd601ec6e8a4daaa4fa1aeae1085" + }, + "Std.Time.Time.Unit.Millisecond": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Millisecond.olean", + "sha256": "f276ecae1131a214858236a4e6e3f495fc7e01d551d3b0bfa98c18301dea92f2" + }, + "Std.Time.Time.Unit.Minute": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Minute.olean", + "sha256": "7c9dc59498474221677908f899f8f8b98ccc4bcb9ced0a76b4b73608e03d1cb6" + }, + "Std.Time.Time.Unit.Nanosecond": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Nanosecond.olean", + "sha256": "6bc08672ed7d3e38d0343ce320ae09b2022fe6dab7e13c589dd11a12f6761147" + }, + "Std.Time.Time.Unit.Second": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Second.olean", + "sha256": "19a8c2259f0d51723c508d313c5d2da2896a5af464e9d6c809e047a772d49969" + }, + "Std.Time.Zoned": { + "relative_path": "lib/lean/Std/Time/Zoned.olean", + "sha256": "84ada81b95c5f170f68d7d2ec234bd3d007ad45d18364e531e5307f2c4d32617" + }, + "Std.Time.Zoned.Database": { + "relative_path": "lib/lean/Std/Time/Zoned/Database.olean", + "sha256": "5a324870d1bb5c102a79717c53840bb87ebbe4c7afb03499a31fb7aa51e04e8f" + }, + "Std.Time.Zoned.Database.Basic": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/Basic.olean", + "sha256": "76d13490a9d782e3c2616634c1d450f81d7978f836d5b7e6969361297a0287c9" + }, + "Std.Time.Zoned.Database.TZdb": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/TZdb.olean", + "sha256": "3345c6282c8805f291bfe6a6c219d4f8d21a2ab8aff2ad46e169aa33c073f777" + }, + "Std.Time.Zoned.Database.TzIf": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/TzIf.olean", + "sha256": "8fe12d507111f7ec04b7d1594959d190604da5bb3a0d944101472cedc2f4da02" + }, + "Std.Time.Zoned.Database.Windows": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/Windows.olean", + "sha256": "50d1a55ee0a71ddf05198a448f019c2bab95dab5d0e930157c220b8d349cbbdd" + }, + "Std.Time.Zoned.DateTime": { + "relative_path": "lib/lean/Std/Time/Zoned/DateTime.olean", + "sha256": "d313bdaf5fdefdc120eb57b5736d495d60ff33febf26db330e1fd99a7a2c396c" + }, + "Std.Time.Zoned.Offset": { + "relative_path": "lib/lean/Std/Time/Zoned/Offset.olean", + "sha256": "41d7f3f24b83359a4da791ff9d6e390bc19a09d0335086be6ac37b809ec75e5b" + }, + "Std.Time.Zoned.TimeZone": { + "relative_path": "lib/lean/Std/Time/Zoned/TimeZone.olean", + "sha256": "406fac44af49c5324d4857665a38f696fe47a0c15fbca5b458279e1c4a32c39e" + }, + "Std.Time.Zoned.ZoneRules": { + "relative_path": "lib/lean/Std/Time/Zoned/ZoneRules.olean", + "sha256": "86b9ebb4ce064c7f5c68fe3933a99d30e53d74c0a967669b7f23baffe77a4f1a" + }, + "Std.Time.Zoned.ZonedDateTime": { + "relative_path": "lib/lean/Std/Time/Zoned/ZonedDateTime.olean", + "sha256": "22285b4d4b6851745f3ba5b2fb79d739eb3000deebcc2ccdfbedec637ee53cd8" + } +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/missing-finite-stream.stderr b/formal/sonification/mat009/audit/verification-probe-001/missing-finite-stream.stderr new file mode 100644 index 0000000..1b5ee80 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/missing-finite-stream.stderr @@ -0,0 +1,7 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/verify_evidence.py", line 134, in + print(json.dumps(verify(args.evidence), sort_keys=True)) + ~~~~~~^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/verify_evidence.py", line 74, in verify + raise ValueError(f"receipt file inventory changed: {name}") +ValueError: receipt file inventory changed: mat009-finite-001 diff --git a/formal/sonification/mat009/audit/verification-probe-001/missing-finite-stream.stdout b/formal/sonification/mat009/audit/verification-probe-001/missing-finite-stream.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/missing-lean-stream.stderr b/formal/sonification/mat009/audit/verification-probe-001/missing-lean-stream.stderr new file mode 100644 index 0000000..e88fa72 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/missing-lean-stream.stderr @@ -0,0 +1,12 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify.py", line 176, in + print(json.dumps(verify(args.attempt, args.lean), sort_keys=True)) + ~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify.py", line 54, in verify + require({p.name for p in attempt.iterdir()} == set(files) | {manifest_path.name}, + ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + "retained evidence file inventory changed") + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify.py", line 40, in require + raise ValueError(message) +ValueError: retained evidence file inventory changed diff --git a/formal/sonification/mat009/audit/verification-probe-001/missing-lean-stream.stdout b/formal/sonification/mat009/audit/verification-probe-001/missing-lean-stream.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/missing-negative-mutant.stderr b/formal/sonification/mat009/audit/verification-probe-001/missing-negative-mutant.stderr new file mode 100644 index 0000000..d739924 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/missing-negative-mutant.stderr @@ -0,0 +1,12 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify_negative.py", line 112, in + print(json.dumps(verify(args.archive), sort_keys=True)) + ~~~~~~^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify_negative.py", line 49, in verify + require(observed == set(files) | {"ARCHIVE_MANIFEST.json"}, + ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + "negative archive file inventory changed") + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify_negative.py", line 32, in require + raise ValueError(message) +ValueError: negative archive file inventory changed diff --git a/formal/sonification/mat009/audit/verification-probe-001/missing-negative-mutant.stdout b/formal/sonification/mat009/audit/verification-probe-001/missing-negative-mutant.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/mutated-proof-checker.stderr b/formal/sonification/mat009/audit/verification-probe-001/mutated-proof-checker.stderr new file mode 100644 index 0000000..1011a2b --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/mutated-proof-checker.stderr @@ -0,0 +1,4 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/checker_mutant_driver.py", line 10, in + from formal.sonification.mat009.lean import check +ModuleNotFoundError: No module named 'formal' diff --git a/formal/sonification/mat009/audit/verification-probe-001/mutated-proof-checker.stdout b/formal/sonification/mat009/audit/verification-probe-001/mutated-proof-checker.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/mutated-source.stderr b/formal/sonification/mat009/audit/verification-probe-001/mutated-source.stderr new file mode 100644 index 0000000..fd6dd23 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/mutated-source.stderr @@ -0,0 +1,4 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/source_drift_driver.py", line 11, in + from formal.sonification.mat009.source import source_bind +ModuleNotFoundError: No module named 'formal' diff --git a/formal/sonification/mat009/audit/verification-probe-001/mutated-source.stdout b/formal/sonification/mat009/audit/verification-probe-001/mutated-source.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/001/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/001/result.json new file mode 100644 index 0000000..c2d8d2e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/001/result.json @@ -0,0 +1,17 @@ +{ + "argv": [ + "python3", + "formal/sonification/mat009/lean/negative.py", + "--lean", + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--out", + "formal/sonification/mat009/lean/negative/001/reproduction" + ], + "cause": "non-unique campaign mutation anchor; no mutation cases executed", + "exit_code": 1, + "script_commit": "574c9ec", + "script_sha256": "5c2894a70267b2eff82241b0aa2cf6e36079ecac451edc401eee9736368ebe2b", + "status": "FAILED_DEVELOPMENT_ATTEMPT", + "stderr_sha256": "405a13f88a20584865d5e7aba8059024eb0af7580e0f788a8c55cb3cda3cf466", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/001/runner.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/001/runner.stderr new file mode 100644 index 0000000..5281259 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/001/runner.stderr @@ -0,0 +1,17 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 171, in + sys.exit(main()) + ~~~~^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 147, in main + for name, mutation in variants().items()] + ~~~~~~~~^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 48, in variants + replace_once(split, + ~~~~~~~~~~~~^^^^^^^ + "s.campaigns role key \u2228 (role = row.role ∧ key = row.campaign)", + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + "(role = row.role ∧ key = row.campaign)"), + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 27, in replace_once + raise ValueError(f"mutation anchor is not unique: {before[:60]!r}") +ValueError: mutation anchor is not unique: 's.campaigns role key ∨ (role = row.role ∧ key = row.campaign' diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/001/runner.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/001/runner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..338f088 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout @@ -0,0 +1,17 @@ +DiagnosticFirstOwner.lean:23:13: warning: unused variable `first` +note: this linter can be disabled with `set_option linter.unusedVariables false` +DiagnosticFirstOwner.lean:35:68: error: unsolved goals +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:55:2: error: unsolved goals +case pos +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:75:38: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/mutant-source.lean.txt new file mode 100644 index 0000000..7dd6c18 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/mutant-source.lean.txt @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some candidate + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/result.json new file mode 100644 index 0000000..c006eca --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/change_diagnostic_first_owner_update/result.json @@ -0,0 +1,37 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-qzlh1__l/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-qzlh1__l/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "DiagnosticFirstOwner", + "mutant_sha256": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner", + "target_module": "DiagnosticFirstOwner" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout new file mode 100644 index 0000000..7afbe9e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout @@ -0,0 +1,29 @@ +SplitModel.lean:157:2: error: tactic 'rfl' failed, the left-hand side + (step s row).crossed +is not definitionally equal to the right-hand side + s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +s : State +row : Row +⊢ (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +SplitModel.lean:173:4: error: type mismatch + Or.inl h +has type + s.crossed ∨ ?m.4965 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:260:33: error: application type mismatch + ih (step s row) (Or.inl h) +argument + Or.inl h +has type + s.crossed ∨ ?m.5382 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:285:36: error: application type mismatch + scan_crossed_sticky (step (scan s before) row) after (Or.inr h) +argument + Or.inr h +has type + ?m.5421 ∨ ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role : Prop +but is expected to have type + (step (scan s before) row).crossed : Prop diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/mutant-source.lean.txt new file mode 100644 index 0000000..bf51182 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/result.json new file mode 100644 index 0000000..e668f74 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_cross_conflict_stickiness/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_cross_conflict_stickiness-b7mgdi0g/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "timed_out": false + } + ], + "detected": false, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "SplitModel", + "mutant_sha256": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stdout new file mode 100644 index 0000000..4bac996 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stdout @@ -0,0 +1,42 @@ +SplitModel.lean:79:23: error: application type mismatch + And.intro (Or.inl htrain) +argument + Or.inl htrain +has type + s.campaigns Role.train key ∨ ?m.3876 : Prop +but is expected to have type + (step s row).campaigns Role.train key : Prop +SplitModel.lean:147:4: error: tactic 'rfl' failed, the left-hand side + (step s row).campaigns role key +is not definitionally equal to the right-hand side + s.campaigns role key ∨ role = row.role ∧ key = row.campaign +case refine_3 +s : State +row : Row +role : Role +key : String +⊢ (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign +SplitModel.lean:169:4: error: type mismatch + Or.inl h +has type + s.campaigns role campaign ∨ ?m.4953 : Prop +but is expected to have type + (step s row).campaigns role campaign : Prop +SplitModel.lean:222:21: error: unsolved goals +case cons +role : Role +key : String +row : Row +rest : List Row +ih : + ∀ (s : State), + (scan s rest).campaigns role key ↔ s.campaigns role key ∨ ∃ row, row ∈ rest ∧ row.role = role ∧ row.campaign = key +s : State +hhead : + (∃ r, r ∈ row :: rest ∧ r.role = role ∧ r.campaign = key) ↔ + row.role = role ∧ row.campaign = key ∨ ∃ r, r ∈ rest ∧ r.role = role ∧ r.campaign = key +⊢ (role = row.role ∧ key = row.campaign ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign) ↔ + role = row.role ∧ key = row.campaign ∨ + s.campaigns role key ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign +SplitModel.lean:368:35: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/mutant-source.lean.txt new file mode 100644 index 0000000..abf1e5e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/result.json new file mode 100644 index 0000000..ef8a788 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/drop_historical_campaign_membership/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_historical_campaign_membership-797k1qgn/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "SplitModel", + "mutant_sha256": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stdout new file mode 100644 index 0000000..1e4568e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stdout @@ -0,0 +1,1493 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: project axiom declaration MAT009.fabricated_physical_admission diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/mutant-source.lean.txt new file mode 100644 index 0000000..6fb45d8 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom fabricated_physical_admission : False + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/result.json new file mode 100644 index 0000000..72ae8e3 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_project_axiom/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "project axiom declaration", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-00-SplitModel.stdout new file mode 100644 index 0000000..a165e03 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-00-SplitModel.stdout @@ -0,0 +1 @@ +SplitModel.lean:379:4: warning: declaration uses 'sorry' diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stdout new file mode 100644 index 0000000..8baf730 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stdout @@ -0,0 +1,1500 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: unapproved transitive axiom sorryAx in MAT009.hidden_unproved (origin SplitModel) diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/mutant-source.lean.txt new file mode 100644 index 0000000..287973b --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +def hidden_unproved : Nat := by sorry + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/result.json new file mode 100644 index 0000000..c24d4fb --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/prohibited_sorry/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "timed_out": false + } + ], + "detected": false, + "expected_diagnostic_text": "sorry", + "expected_failure_module": "SplitModel", + "mutant_sha256": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/result.json new file mode 100644 index 0000000..6215fda --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/result.json @@ -0,0 +1,47 @@ +{ + "REFINEMENT_PROVED": "OPEN", + "cases": [ + { + "detected": false, + "expected_failure_module": "SplitModel", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "SplitModel", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "TypedConsumer", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer" + }, + { + "detected": true, + "expected_failure_module": "DiagnosticFirstOwner", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit" + }, + { + "detected": false, + "expected_failure_module": "SplitModel", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit" + } + ], + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "negative_runner_commit": "496c90c97ef0e5e0294dee706a842a888a3c47ea", + "negative_runner_sha256": "b06e5f54e157c61475661e5066321e65f3692b177e116f52c18f47337ce043c3", + "proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "scope": "negative controls for mathematical proof and trust checker only", + "status": "FAIL" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..85516a3 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout @@ -0,0 +1,68 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff : True +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +TypedConsumer.lean:43:9: error: function expected at + M009_R6_final_leakage_iff +term has type + True +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' does not depend on any axioms +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, sorryAx, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/mutant-source.lean.txt new file mode 100644 index 0000000..bd8b105 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/mutant-source.lean.txt @@ -0,0 +1,369 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff : True := by trivial + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/result.json new file mode 100644 index 0000000..9882436 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/002/weaken_final_leakage_theorem/result.json @@ -0,0 +1,50 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-tdtq_18o/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-tdtq_18o/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-tdtq_18o/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "M009_R6_final_leakage_iff", + "expected_failure_module": "TypedConsumer", + "mutant_sha256": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..338f088 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout @@ -0,0 +1,17 @@ +DiagnosticFirstOwner.lean:23:13: warning: unused variable `first` +note: this linter can be disabled with `set_option linter.unusedVariables false` +DiagnosticFirstOwner.lean:35:68: error: unsolved goals +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:55:2: error: unsolved goals +case pos +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:75:38: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/mutant-source.lean.txt new file mode 100644 index 0000000..7dd6c18 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/mutant-source.lean.txt @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some candidate + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/result.json new file mode 100644 index 0000000..fb1e6cb --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/change_diagnostic_first_owner_update/result.json @@ -0,0 +1,37 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-5g641ca4/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-5g641ca4/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "DiagnosticFirstOwner", + "mutant_sha256": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner", + "target_module": "DiagnosticFirstOwner" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout new file mode 100644 index 0000000..7afbe9e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout @@ -0,0 +1,29 @@ +SplitModel.lean:157:2: error: tactic 'rfl' failed, the left-hand side + (step s row).crossed +is not definitionally equal to the right-hand side + s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +s : State +row : Row +⊢ (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +SplitModel.lean:173:4: error: type mismatch + Or.inl h +has type + s.crossed ∨ ?m.4965 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:260:33: error: application type mismatch + ih (step s row) (Or.inl h) +argument + Or.inl h +has type + s.crossed ∨ ?m.5382 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:285:36: error: application type mismatch + scan_crossed_sticky (step (scan s before) row) after (Or.inr h) +argument + Or.inr h +has type + ?m.5421 ∨ ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role : Prop +but is expected to have type + (step (scan s before) row).crossed : Prop diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/mutant-source.lean.txt new file mode 100644 index 0000000..bf51182 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/result.json new file mode 100644 index 0000000..4cf3c03 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_cross_conflict_stickiness/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_cross_conflict_stickiness-mplmly4j/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "application type mismatch", + "expected_failure_module": "SplitModel", + "mutant_sha256": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stdout new file mode 100644 index 0000000..4bac996 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stdout @@ -0,0 +1,42 @@ +SplitModel.lean:79:23: error: application type mismatch + And.intro (Or.inl htrain) +argument + Or.inl htrain +has type + s.campaigns Role.train key ∨ ?m.3876 : Prop +but is expected to have type + (step s row).campaigns Role.train key : Prop +SplitModel.lean:147:4: error: tactic 'rfl' failed, the left-hand side + (step s row).campaigns role key +is not definitionally equal to the right-hand side + s.campaigns role key ∨ role = row.role ∧ key = row.campaign +case refine_3 +s : State +row : Row +role : Role +key : String +⊢ (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign +SplitModel.lean:169:4: error: type mismatch + Or.inl h +has type + s.campaigns role campaign ∨ ?m.4953 : Prop +but is expected to have type + (step s row).campaigns role campaign : Prop +SplitModel.lean:222:21: error: unsolved goals +case cons +role : Role +key : String +row : Row +rest : List Row +ih : + ∀ (s : State), + (scan s rest).campaigns role key ↔ s.campaigns role key ∨ ∃ row, row ∈ rest ∧ row.role = role ∧ row.campaign = key +s : State +hhead : + (∃ r, r ∈ row :: rest ∧ r.role = role ∧ r.campaign = key) ↔ + row.role = role ∧ row.campaign = key ∨ ∃ r, r ∈ rest ∧ r.role = role ∧ r.campaign = key +⊢ (role = row.role ∧ key = row.campaign ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign) ↔ + role = row.role ∧ key = row.campaign ∨ + s.campaigns role key ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign +SplitModel.lean:368:35: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/mutant-source.lean.txt new file mode 100644 index 0000000..abf1e5e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/result.json new file mode 100644 index 0000000..60e4592 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/drop_historical_campaign_membership/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_historical_campaign_membership-4ipi38ta/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "SplitModel", + "mutant_sha256": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stdout new file mode 100644 index 0000000..1e4568e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stdout @@ -0,0 +1,1493 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: project axiom declaration MAT009.fabricated_physical_admission diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/mutant-source.lean.txt new file mode 100644 index 0000000..6fb45d8 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom fabricated_physical_admission : False + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/result.json new file mode 100644 index 0000000..a53a3d7 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_project_axiom/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "project axiom declaration", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-00-SplitModel.stdout new file mode 100644 index 0000000..a165e03 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-00-SplitModel.stdout @@ -0,0 +1 @@ +SplitModel.lean:379:4: warning: declaration uses 'sorry' diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stdout new file mode 100644 index 0000000..8baf730 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stdout @@ -0,0 +1,1500 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: unapproved transitive axiom sorryAx in MAT009.hidden_unproved (origin SplitModel) diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/mutant-source.lean.txt new file mode 100644 index 0000000..287973b --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +def hidden_unproved : Nat := by sorry + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/result.json new file mode 100644 index 0000000..4fcaa6e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/prohibited_sorry/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "sorryAx", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/result.json new file mode 100644 index 0000000..7831e91 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/result.json @@ -0,0 +1,47 @@ +{ + "REFINEMENT_PROVED": "OPEN", + "cases": [ + { + "detected": true, + "expected_failure_module": "SplitModel", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "SplitModel", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "TypedConsumer", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer" + }, + { + "detected": true, + "expected_failure_module": "DiagnosticFirstOwner", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit" + } + ], + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "negative_runner_commit": "5620029fb724ac41827a0c41c4c677b9594464f3", + "negative_runner_sha256": "874ca7ff059394e97cc908d921dec51bbc0ff852c354baf1c8da7a7d557a352c", + "proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "scope": "negative controls for mathematical proof and trust checker only", + "status": "PASS" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..85516a3 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout @@ -0,0 +1,68 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff : True +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +TypedConsumer.lean:43:9: error: function expected at + M009_R6_final_leakage_iff +term has type + True +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' does not depend on any axioms +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, sorryAx, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/result.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/result.json new file mode 100644 index 0000000..b9c7631 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/003/weaken_final_leakage_theorem/result.json @@ -0,0 +1,50 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-ndmeeadq/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-ndmeeadq/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-ndmeeadq/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "M009_R6_final_leakage_iff", + "expected_failure_module": "TypedConsumer", + "mutant_sha256": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/negative-archive/ARCHIVE_MANIFEST.json b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/ARCHIVE_MANIFEST.json new file mode 100644 index 0000000..6f64e7a --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/negative-archive/ARCHIVE_MANIFEST.json @@ -0,0 +1,109 @@ +{ + "accepted_attempt": "003", + "accepted_case_count": 6, + "files_sha256": { + "001/result.json": "092c87de243607f5721b9c55113b4223a2d3301e2c8c8acab82309c1afd24aeb", + "001/runner.stderr": "405a13f88a20584865d5e7aba8059024eb0af7580e0f788a8c55cb3cda3cf466", + "001/runner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "002/change_diagnostic_first_owner_update/mutant-source.lean.txt": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "002/change_diagnostic_first_owner_update/result.json": "759e5e2ec2b13fd4565d8419417628beb3a829357f53aa01ea18654ebef5c061", + "002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "002/drop_cross_conflict_stickiness/mutant-source.lean.txt": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "002/drop_cross_conflict_stickiness/result.json": "ccce8d856ccf63fa7bef4808bed50b06c7b68617e91351da87e617a555f08dc7", + "002/drop_historical_campaign_membership/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/drop_historical_campaign_membership/build-00-SplitModel.stdout": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "002/drop_historical_campaign_membership/mutant-source.lean.txt": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "002/drop_historical_campaign_membership/result.json": "9cfe5f060dde968cf7677f36bf0fc7305ac4bc8085bb75f4fd751c0106d558dc", + "002/prohibited_project_axiom/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "002/prohibited_project_axiom/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-04-LeanAudit.stdout": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "002/prohibited_project_axiom/mutant-source.lean.txt": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "002/prohibited_project_axiom/result.json": "ae8389c3439aaf40f6df4dde82ca0c9bf2c5ac21077f0cbf7ebee9620c6ed20b", + "002/prohibited_sorry/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-00-SplitModel.stdout": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "002/prohibited_sorry/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-04-LeanAudit.stdout": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "002/prohibited_sorry/mutant-source.lean.txt": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "002/prohibited_sorry/result.json": "863e887d061ebe06d802c76738510272c0d8b0521ca80a28728503f01db0e7cd", + "002/result.json": "7e72d51436d9d6c2408f1d92dda97d6f98d36707c5eb6b3b5ed9fbbce4143f6d", + "002/weaken_final_leakage_theorem/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "002/weaken_final_leakage_theorem/mutant-source.lean.txt": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "002/weaken_final_leakage_theorem/result.json": "8293ba459bb90648c0448890aae54d5d2b7c01cb09e8ee71d5a4e55e3cc5a1f6", + "003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "003/change_diagnostic_first_owner_update/mutant-source.lean.txt": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "003/change_diagnostic_first_owner_update/result.json": "685fd47652221dab5c0e1f79a0d989cc6207881665c43c39ccbe685a2dd8eed4", + "003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "003/drop_cross_conflict_stickiness/mutant-source.lean.txt": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "003/drop_cross_conflict_stickiness/result.json": "7b18e2919bfb7cd8fbf722edb1712539a6953cc86d811b8dc3f3d95f6f24e057", + "003/drop_historical_campaign_membership/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/drop_historical_campaign_membership/build-00-SplitModel.stdout": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "003/drop_historical_campaign_membership/mutant-source.lean.txt": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "003/drop_historical_campaign_membership/result.json": "d11211491d3439e7e9033ed21758a7b84404fd0ac18684f33a1fad8a9e3e101f", + "003/prohibited_project_axiom/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "003/prohibited_project_axiom/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-04-LeanAudit.stdout": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "003/prohibited_project_axiom/mutant-source.lean.txt": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "003/prohibited_project_axiom/result.json": "3f1374a1123f4b4bdbe49e6bd6dd8f71ba2932050b464f5f71c7968ce2364d43", + "003/prohibited_sorry/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-00-SplitModel.stdout": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "003/prohibited_sorry/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-04-LeanAudit.stdout": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "003/prohibited_sorry/mutant-source.lean.txt": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "003/prohibited_sorry/result.json": "0fc83b4837938c12c89bba62bb74070eda233d7ce44fa13a56a7073719e1197d", + "003/result.json": "6a2982ab558b83f472c60052c458055f30775d8e53d4f0a0015ff446d88d18dd", + "003/weaken_final_leakage_theorem/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "003/weaken_final_leakage_theorem/mutant-source.lean.txt": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "003/weaken_final_leakage_theorem/result.json": "65b7710a986a187cc2ed3d85878240fd22a59b4ce305b6ce3edc412b026768da" + }, + "nominal_proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "prior_failed_attempts": [ + "001", + "002" + ], + "schema": "sonification-mat009-lean-negative-archive-v1" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/result.json b/formal/sonification/mat009/audit/verification-probe-001/result.json new file mode 100644 index 0000000..41ef268 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/result.json @@ -0,0 +1,85 @@ +{ + "results": [ + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/source_drift_driver.py", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-001/source-drift" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "working-tree target differs", + "expected_rejection": false, + "label": "mutated-source", + "stderr_sha256": "4662f52b4cb52f218efc05978b9b8c9a9e135cb28daeecea08ade325e117b8cc", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/verify_evidence.py", + "--evidence", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-001/source-receipts" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "receipt file inventory changed", + "expected_rejection": true, + "label": "missing-finite-stream", + "stderr_sha256": "fcce5190b7817e5decdc23ce4155c9f94d21c71c29e1888f23e942a4576855bc", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify.py", + "--attempt", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-001/lean-attempt" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "evidence file inventory changed", + "expected_rejection": true, + "label": "missing-lean-stream", + "stderr_sha256": "e8d665fbd4c7fc24de8d32efc6dd124738809c6c3e0d929ef9d5eb8d4cd46f44", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify_negative.py", + "--archive", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-001/negative-archive" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "archive file inventory changed", + "expected_rejection": true, + "label": "missing-negative-mutant", + "stderr_sha256": "a9e91f39be3d5749edd90f3cd159be517255a1b1d4374ea044f3f2e4d9f781ef", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/checker_mutant_driver.py", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-001/checker-result" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "stale proof input: SplitModel.lean", + "expected_rejection": false, + "label": "mutated-proof-checker", + "stderr_sha256": "61e0d9573021b0e0f7c945ee2987f3aa8258fff645b89b2f7dc727616502ffd7", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + ], + "source_mutant_sha256": "c9e950367bdd918511b3407b76866682af273e1072f72f476ae7398221cd5c3e", + "status": "FAIL" +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-drift/materials/mat_spec_008.py b/formal/sonification/mat009/audit/verification-probe-001/source-drift/materials/mat_spec_008.py new file mode 100644 index 0000000..3117adb --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-drift/materials/mat_spec_008.py @@ -0,0 +1,625 @@ +"""MAT-SPEC-008: original-experiment evidence acquisition and independence gate. + +SPDX-License-Identifier: MPL-2.0 +Copyright (c) 2026 Trent Slade / QSOL-IMC. + +This is a source availability and measurement-provenance audit, not physical +replication, classifier evaluation, or generated sampled audio. +""" +from __future__ import annotations + +import csv +import io +import json +import os +import re +import stat +from contextlib import suppress +from fractions import Fraction +from itertools import combinations +from pathlib import Path, PurePosixPath + +from materials import mat_spec, mat_spec_006, mat_spec_007 + +PROFILE = "MAT-SPEC-008" +VERSION = "0.1.0" +PARENT_COMMIT = "b97348ff8fcf3f57764dec21a8914f153f96a745" +FOUNDATIONAL_DOI = "10.5281/zenodo.24062652" +SOURCE_PATH = "data/materials/helium4/mat_spec_008_source_catalogue.json" +SPEC_PATH = "spec/mat-spec-008.v0.1.json" +CATALOGUE_SHA256 = "6b6a973f46d1a748c5f94760a69e95899b5cc06ea717e1403b444eecdd880d88" +CAMPAIGNS = ("AL71_SVP", "GM75_SVP", "LC83_SVP", "STS52_1992") +FAMILIES = { + "AL71_SVP": "BELL_AHLERS", + "GM75_SVP": "MINNESOTA_GASPARINI_MOLDOVER", + "LC83_SVP": "STANFORD_LIPA", + "STS52_1992": "STANFORD_LIPA", +} +DOC_IDS = ( + "LC83_NASA_1984", "AHLERS_PRA_1971", "MUELLER_PRB_1976", + "GASPARINI_MOLDOVER_PRB_1975", "GASPARINI_GAETA_PRB_1978", + "STS52_NASA_1994", "STS52_PRL_1996", "STS52_PRB_2003", + "DONNELLY_BARENGHI_1998", "BARMATZ_RMP_2007", +) +OUTPUT_NAMES = frozenset({ + "contract.json", "source-catalogue.json", "campaigns.csv", + "candidate-pairs.csv", "measurement-audit.json", "admission.json", + "protocol.json", "manifest.json", +}) +IMPLEMENTATION_PATHS = ( + "materials/mat_spec_008.py", "scripts/build_mat_spec_008.py", +) +# Frozen MAT-SPEC-007 eight-output baseline from merged-main GitHub CI. +PARENT_V7_SHA256 = { + "audit.json": "0cc0d5ec77db4285ab379e15bbaf9a69b05cd367fd428cb6c227b8b8605a4d06", + "contract.json": "9e0eb1bf1e69599976dd57215ddeca956480c96ead61e36b055c67aa3125fc92", + "fit-summaries.csv": ( + "b3457eeafd8bda8f8b9ebd63d4cd72af825fd8bd04e2660d01f637578db79489" + ), + "lineage.json": "acdbabfe12116b930ca84ba8cc50a3e2a4f83493a6fbafef5915ffefae3727bd", + "manifest.json": "19fda1a900d051352d274f8b00fbd9e2ed7a44e1c90ae00c4e40bc30d1e6d5fc", + "pair-relations.csv": "3528b8f1700479d4f4ced51ab1a43535d800fea266d246a7a574967bf86ad2d4", + "receiver.json": "c2edb389a353e71748464fcfc4dbf88b92f1ce3bf28dad43d4980b0c5cdcde01", + "replication-gate.json": ( + "253b864e83ab4d5d36be16f6ec4ad71e0a7267a6b9c6fccfaf990a0b41950574" + ), +} + + +def _identity(value: object) -> str: + if ( + not isinstance(value, str) or not value or len(value) > 100 + or value != value.strip() or re.fullmatch(r"[A-Z0-9_]+", value) is None + ): + raise ValueError("invalid or empty source experiment identity") + return value + + +def parse_catalogue(raw: bytes) -> dict: + """Strict membership/lineage check; neither a PDF nor remote data fetch.""" + if mat_spec.sha256(raw) != CATALOGUE_SHA256: + raise ValueError("MAT-SPEC-008 source catalogue SHA-256 mismatch") + try: + data = json.loads(raw) + except (ValueError, UnicodeDecodeError) as exc: + raise ValueError("invalid source-catalogue JSON") from exc + if ( + data != EXPECTED_CATALOGUE + or data.get("profile") != PROFILE + or data.get("version") != VERSION + or len(data.get("source_docs", [])) != len(DOC_IDS) + ): + raise ValueError("MAT-SPEC-008 frozen source catalogue mismatch") + docs = data["source_docs"] + if tuple(d["doc_id"] for d in docs) != DOC_IDS: + raise ValueError("source catalogue identity drift") + if len({d["doc_id"] for d in docs}) != len(DOC_IDS): + raise ValueError("duplicate source document ID") + for d in docs: + _identity(d["doc_id"]) + campaign = d["campaign"] + if campaign is None: + if d["document_kind"] not in {"EVALUATED_COMPILATION", "SECONDARY_FIT_REVIEW"}: + raise ValueError("unassigned experiment identity") + elif _identity(campaign) not in CAMPAIGNS: + raise ValueError("unrecognized experiment campaign") + if campaign and d["lab_family"] != FAMILIES[campaign]: + raise ValueError("source-family mismatch") + if not isinstance(d["source_bound_measurement_rows"], int): + raise ValueError("invalid claimed original numeric row count") + if ( + d["source_bound_measurement_rows"] < 0 + or d["per_row_calibrated_uncertainty"] is not False + or d["orthogonal_phase_diagnostic"] is not False + ): + raise ValueError("forged admitted evidence flags") + return data + + +def source_audit( + catalogue: dict, actual_measurement_rows: list[dict], fit_summaries: list[dict] +) -> tuple[list[dict], list[dict], dict]: + """Do not promote a literature DOI or reanalysis to a measured campaign.""" + docs = catalogue["source_docs"] + if ( + len(actual_measurement_rows) != 12 + or len(fit_summaries) != 4 + or {r["source_campaign_id"] for r in actual_measurement_rows} + != {mat_spec_006.CAMPAIGN} + or tuple(r["acquisition_campaign"] for r in fit_summaries) != CAMPAIGNS + ): + raise ValueError("MAT-SPEC-006/007 original acquisition lineage drift") + if any( + r["row_uncertainty_J_per_mol_K"] is not None + or r["independent_physical_phase_diagnostic"] is not None + or r["independent_phase_label"] is not None + for r in actual_measurement_rows + ): + raise ValueError("forged original row uncertainties or phase diagnostics") + + totals = {camp: 0 for camp in CAMPAIGNS} + for d in docs: + if d["source_bound_measurement_rows"]: + if d["doc_id"] != "LC83_NASA_1984": + raise ValueError("unsupported independent numeric measurements") + totals["LC83_SVP"] += d["source_bound_measurement_rows"] + if totals["LC83_SVP"] != len(actual_measurement_rows): + raise ValueError("admitted NASA measurement count drift") + campaigns = [] + for camp in CAMPAIGNS: + records = [d for d in docs if d["campaign"] == camp] + original = [d for d in records if d["document_kind"] in { + "ORIGINAL_PROCESSED_MEASUREMENT_TABLE", + "ORIGINAL_EXPERIMENT_PUBLICATION", + "ORIGINAL_EXPERIMENT_CONFERENCE", + }] + if not original: + raise ValueError("campaign has no attributed original experimental source") + campaigns.append({ + "campaign": camp, + "lab_family": FAMILIES[camp], + "source_documents": len(records), + "original_source_docs": len(original), + "source_pinned_processed_measurement_rows": totals[camp], + "per_row_calibrated_uncertainties": 0, + "independent_phase_diagnostic_rows": 0, + "acquisition_run_independence_attested": False, + "admission_status": "BLOCKED_NO_INDEPENDENT_MEASUREMENT_PACKET", + }) + pairs = [] + for a, b in combinations(campaigns, 2): + pairs.append({ + "campaign_a": a["campaign"], "campaign_b": b["campaign"], + "distinct_published_campaigns": True, + "different_lab_family": a["lab_family"] != b["lab_family"], + "both_have_source_pinned_original_measurements": ( + a["source_pinned_processed_measurement_rows"] > 0 + and b["source_pinned_processed_measurement_rows"] > 0 + ), + "experiment_run_independence_attested": False, + "eligible_for_independent_replication": False, + }) + if ( + len(pairs) != 6 or sum(x["different_lab_family"] for x in pairs) != 5 + or sum(x["both_have_source_pinned_original_measurements"] for x in pairs) != 0 + ): + raise ValueError("independence pair conservation failure") + report = { + "profile": PROFILE, "version": VERSION, + "reviewed_publication_documents": len(docs), + "published_original_acquisition_campaigns": len(campaigns), + "distinct_lab_families": len(set(FAMILIES.values())), + "original_source_pinned_processed_measurement_campaigns": sum( + x["source_pinned_processed_measurement_rows"] > 0 for x in campaigns + ), + "source_pinned_processed_measurement_rows": len(actual_measurement_rows), + "available_row_level_calibrated_uncertainties": 0, + "available_independent_phase_diagnostic_rows": 0, + "secondary_review_fitted_records": len(fit_summaries), + "candidate_campaign_pairs": len(pairs), + "candidate_cross_lab_pairs": 5, + "measurement_level_replicable_pairs": 0, + "do_not_add_reanalyses_as_new_experiments": True, + "different_publications_not_independent_measurement_packets": True, + } + return campaigns, pairs, report + + +def _rows_csv(rows: list[dict]) -> bytes: + out = io.StringIO(newline="") + fields = tuple(rows[0]) + writer = csv.DictWriter(out, fieldnames=fields, lineterminator="\n") + writer.writeheader() + writer.writerows(rows) + return out.getvalue().encode("ascii") + + +def _decimal(value: object) -> Fraction: + if not isinstance(value, str) or re.fullmatch( + r"(?:0|[1-9][0-9]*)(?:\.[0-9]+)?", value + ) is None: + raise ValueError("missing or invalid positive calibrated quantity") + number = Fraction(value) + if number <= 0: + raise ValueError("missing or zero calibrated quantity") + return number + + +def validate_future_measurement_packet(records: list[dict]) -> dict: + """Structure only; caller assertions cannot prove real-world measurements.""" + reasons: set[str] = set() + if not records: + return { + "status": "BLOCKED", "reasons": ["EMPTY_MEASUREMENT_PACKET"], + "physical_evidence_admitted": False, "independence_authenticated": False, + } + experiment_to_lab: dict[str, str] = {} + experiment_to_source: dict[str, str] = {} + experiment_to_hash: dict[str, str] = {} + run_to_campaign: dict[str, str] = {} + document_to_campaign: dict[str, str] = {} + hash_to_campaign: dict[str, str] = {} + phases_by_campaign: dict[str, set[str]] = {} + seen_rows = set() + campaigns = set() + labs = set() + for row in records: + if not isinstance(row, dict): + reasons.add("MALFORMED_CANDIDATE_RECORD") + continue + try: + camp = _identity(row.get("campaign_id")) + lab = _identity(row.get("lab_family_id")) + run = _identity(row.get("original_run_id")) + doc = _identity(row.get("source_document_id")) + identifier = _identity(row.get("row_id")) + except ValueError: + reasons.add("MISSING_OR_INVALID_SOURCE_IDENTITIES") + continue + if identifier in seen_rows: + reasons.add("DUPLICATE_MEASUREMENT_ROW_ID") + seen_rows.add(identifier) + campaigns.add(camp) + labs.add(lab) + if camp in experiment_to_lab and experiment_to_lab[camp] != lab: + reasons.add("CAMPAIGN_LAB_IDENTITY_CONTRADICTION") + experiment_to_lab[camp] = lab + # Source, document and run identities must not migrate between + # purportedly independent acquisition campaigns. + source_key = doc + ":" + run + if camp in experiment_to_source and experiment_to_source[camp] != source_key: + reasons.add("CAMPAIGN_RUN_OR_DOCUMENT_INCONSISTENT") + experiment_to_source[camp] = source_key + for key, owner, prior in ( + ("REUSED_ORIGINAL_RUN_ACROSS_CAMPAIGNS", run_to_campaign, run), + ("REUSED_ORIGINAL_DOCUMENT_ACROSS_CAMPAIGNS", document_to_campaign, doc), + ): + if prior in owner and owner[prior] != camp: + reasons.add(key) + owner[prior] = camp + declared_phase = row.get("phase") + if not isinstance(declared_phase, str): + reasons.add("UNVERIFIED_PHASE_LABEL") + declared_phase = "INVALID" + phases_by_campaign.setdefault(camp, set()).add(declared_phase) + if row.get("source_type") != "ORIGINAL_EXPERIMENTAL_RECORD": + reasons.add("DERIVED_FIT_OR_COMPILATION_IS_NOT_PRIMARY_DATA") + if row.get("synthetic_fixture") is True: + reasons.add("SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT") + if row.get("diagnostic_basis") != "INDEPENDENT_NON_TEMPERATURE_DIAGNOSTIC": + reasons.add("CIRCULAR_OR_MISSING_PHASE_DIAGNOSTIC") + if declared_phase not in ("HE_I", "HE_II"): + reasons.add("UNVERIFIED_PHASE_LABEL") + try: + _decimal(row.get("measurement_value")) + _decimal(row.get("measurement_sigma")) + _decimal(row.get("diagnostic_sigma")) + except ValueError: + reasons.add("MISSING_CALIBRATED_MEASUREMENT_UNCERTAINTY") + digest = row.get("source_sha256") + if ( + not isinstance(digest, str) + or re.fullmatch(r"[0-9a-f]{64}", digest) is None + or row.get("pressure_condition") not in ( + "HE4_SVP", "DOCUMENTED_FIXED_PRESSURE" + ) + ): + reasons.add("SOURCE_HASH_OR_PHYSICAL_CONDITION_NOT_DOCUMENTED") + else: + if digest in hash_to_campaign and hash_to_campaign[digest] != camp: + reasons.add("REUSED_SOURCE_BYTES_ACROSS_CAMPAIGNS") + hash_to_campaign[digest] = camp + if camp in experiment_to_hash and experiment_to_hash[camp] != digest: + reasons.add("CAMPAIGN_SOURCE_BYTES_INCONSISTENT") + experiment_to_hash[camp] = digest + if any(phases != {"HE_I", "HE_II"} for phases in phases_by_campaign.values()): + reasons.add("BOTH_PHASES_REQUIRED_FOR_EACH_CAMPAIGN") + if len(campaigns) < 2 or len(labs) < 2: + reasons.add("TWO_INDEPENDENT_CAMPAIGNS_AND_LABS_REQUIRED") + if len(set(experiment_to_source.values())) < 2: + reasons.add("DISTINCT_ORIGINAL_RUNS_REQUIRED") + # Do not use the user's declared campaign strings as proof of independence. + return { + "status": "BLOCKED" if reasons else "STRUCTURAL_ONLY_UNAUTHENTICATED", + "reasons": sorted(reasons), + "candidate_rows": len(records), + "described_campaigns": len(campaigns), + "described_labs": len(labs), + "physical_evidence_admitted": False, + "independence_authenticated": False, + "heldout_accuracy": None, + "note": "A structural pass never authenticates original run bytes or phase labels", + } + + +def evidence_admission(report: dict, catalogue: dict) -> dict: + if ( + report["original_source_pinned_processed_measurement_campaigns"] != 1 + or report["source_pinned_processed_measurement_rows"] != 12 + or report["measurement_level_replicable_pairs"] != 0 + or report["available_row_level_calibrated_uncertainties"] != 0 + or report["available_independent_phase_diagnostic_rows"] != 0 + ): + raise ValueError("unanticipated scientific admission state") + return { + "status": "BLOCKED_INSUFFICIENT_INDEPENDENT_MEASUREMENT_DATA", + "source_catalogue_profile": catalogue["profile"], + "one_campaign_processed_excerpt": "REPLAY_VERIFIED", + "independent_experimental_replication": "NOT_DEMONSTRATED", + "distinct_campaigns_described": 4, + "independent_measurement_campaigns_with_source_pinned_rows": 1, + "independent_measurement_campaign_pair_count": 0, + "independently_verified_raw_acquisition_campaigns": 0, + "train_test_split": "NOT_PERFORMED", + "trained_phase_classifier": False, + "physical_phase_accuracy": None, + "source_separated_heldout_accuracy": None, + "calibrated_error_comparison": "BLOCKED_NO_PER_ROW_ERRORS", + "reasons": [ + "SECOND_INDEPENDENT_MEASUREMENT_LEVEL_CORPUS_NOT_ADMITTED", + "PUBLISHED_ARTICLE_OR_REFIT_NOT_AN_ORIGINAL_ROW_PACKET", + "NO_TWO_SOURCE_PINNED_CAMPAIGNS", + "ORIGINAL_PROCESSED_MEASUREMENT_ROWS_LACK_PER_ROW_ERRORS", + "NO_ORTHOGONAL_PHYSICAL_PHASE_LABELS", + "NO_INDEPENDENT_ORIGINAL_RUN_IDENTITY_AUTHENTICATION", + "NO_PREREGISTERED_SOURCE_SEPARATED_HELDOUT_EVALUATION", + ], + "next": "MAT-SPEC-009 may only attempt physical validation after independent admission", + "program_end": "MAT-SPEC-010", + "no_audio_generated": True, + } + + +def build_evidence(root: Path) -> dict[str, bytes]: + """Rebuild 001..007, verify source excerpt and export negative evidence.""" + parent = mat_spec_007.build_evidence(root) + if set(parent) != mat_spec_007.OUTPUT_NAMES: + raise ValueError("MAT-SPEC-007 parent artifact membership drift") + hashes = {name: mat_spec.sha256(raw) for name, raw in parent.items()} + if hashes != PARENT_V7_SHA256: + raise ValueError("frozen MAT-SPEC-007 parent output SHA-256 drift") + manifest = json.loads(parent["manifest.json"]) + if ( + manifest.get("profile") != "MAT-SPEC-007" + or manifest.get("version") != "0.1.0" + or manifest.get("parent_commit") != mat_spec_007.PARENT_COMMIT + or manifest.get("foundational_mat_spec_001_doi") != FOUNDATIONAL_DOI + ): + raise ValueError("unexpected MAT-SPEC-007 parent lineage") + for name, entry in manifest["outputs"].items(): + if name not in parent or mat_spec.sha256(parent[name]) != entry["sha256"]: + raise ValueError("MAT-SPEC-007 parent manifest inconsistency") + raw_catalogue = mat_spec.read_regular(root / SOURCE_PATH) + raw_spec = mat_spec.read_regular(root / SPEC_PATH) + catalogue = parse_catalogue(raw_catalogue) + try: + contract = json.loads(raw_spec) + except (UnicodeDecodeError, ValueError) as exc: + raise ValueError("invalid MAT-SPEC-008 contract") from exc + if contract != EXPECTED_SPEC: + raise ValueError("frozen MAT-SPEC-008 contract drift") + original_bytes = mat_spec.read_regular(root / mat_spec_006.DATA_PATH) + original = mat_spec_006.parse_measurements(original_bytes) + fits = list(csv.DictReader(io.StringIO(parent["fit-summaries.csv"].decode("ascii")))) + campaigns, pairs, report = source_audit(catalogue, original, fits) + admission = evidence_admission(report, catalogue) + protocol = { + "status": "FUTURE_MEASUREMENT_PACKET_PREFLIGHT", + "review_timing": "DESIGNED_AFTER_INSPECTING_EXISTING_SOURCES", + "required": [ + "TWO_PROVEN_INDEPENDENT_ORIGINAL_MEASUREMENT_CAMPAIGNS", + "ROW_LEVEL_MEASUREMENT_AND_DIAGNOSTIC_ERRORS", + "NON_TEMPERATURE_DERIVED_PHASE_LABELS", + "NO_SOURCE_RUN_OR_CROSS_LAB_DEPENDENCY", + "SOURCE_PINNED_MEASUREMENT_PACKET_AND_CALIBRATION", + "PREREGISTERED_SOURCE_SEPARATED_HELDOUT_PLAN", + ], + "synthetic_fixture_controls_are_empirical_evidence": False, + "structural_pass_alone_can_admit_physics": False, + "performance_score": None, + "program_end": "MAT-SPEC-010", + } + products = { + "contract.json": mat_spec.canonical_json(contract), + "source-catalogue.json": mat_spec.canonical_json(catalogue), + "campaigns.csv": _rows_csv(campaigns), + "candidate-pairs.csv": _rows_csv(pairs), + "measurement-audit.json": mat_spec.canonical_json(report), + "admission.json": mat_spec.canonical_json(admission), + "protocol.json": mat_spec.canonical_json(protocol), + } + implementation = { + path: mat_spec.sha256(mat_spec.read_regular(root / path)) + for path in IMPLEMENTATION_PATHS + } + output_manifest = { + "profile": PROFILE, "version": VERSION, "parent_commit": PARENT_COMMIT, + "parent_outputs": { + name: {"sha256": value, "bytes": len(parent[name])} + for name, value in sorted(hashes.items()) + }, + "source_catalogue": { + "path": SOURCE_PATH, "sha256": mat_spec.sha256(raw_catalogue), + "bytes": len(raw_catalogue), + }, + "original_measurement_excerpt": { + "path": mat_spec_006.DATA_PATH, + "sha256": mat_spec.sha256(original_bytes), + "rows": len(original), + }, + "contract": {"path": SPEC_PATH, "sha256": mat_spec.sha256(raw_spec)}, + "implementation": implementation, + "outputs": { + name: {"sha256": mat_spec.sha256(raw), "bytes": len(raw)} + for name, raw in sorted(products.items()) + }, + "foundational_mat_spec_001_doi": FOUNDATIONAL_DOI, + "serialization": "ASCII canonical sorted compact JSON LF, CSV LF", + "manifest_self_hash": None, + "canonical_pcm_sha256": None, + "canonical_wav_sha256": None, + "audio_generated": False, + } + products["manifest.json"] = mat_spec.canonical_json(output_manifest) + return products + + +def write_evidence(root: Path, destination: str, products: dict[str, bytes]) -> Path: + """Anchored no-follow exclusive symbolic-only output.""" + path = PurePosixPath(destination) + if ( + not destination or path.is_absolute() or "\\" in destination + or any(component in {"", ".", ".."} for component in destination.split("/")) + ): + raise ValueError("invalid symbolic output destination") + if set(products) != OUTPUT_NAMES or any( + PurePosixPath(name).name != name + or Path(name).suffix not in {".csv", ".json"} for name in products + ): + raise ValueError("forbidden non-symbolic output membership") + flags = os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW + fds = [os.open(root, flags)] + try: + for component in path.parts[:-1]: + with suppress(FileExistsError): + os.mkdir(component, mode=0o755, dir_fd=fds[-1]) + fds.append(os.open(component, flags, dir_fd=fds[-1])) + parent_fd = fds[-1] + os.mkdir(path.parts[-1], mode=0o755, dir_fd=parent_fd) + fds.append(os.open(path.parts[-1], flags, dir_fd=parent_fd)) + output_fd = fds[-1] + for name in sorted(products): + fd = os.open( + name, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, + mode=0o644, dir_fd=output_fd, + ) + with os.fdopen(fd, "wb") as target: + target.write(products[name]) + opened = os.fstat(output_fd) + visible = os.stat(path.parts[-1], dir_fd=parent_fd, follow_symlinks=False) + if not stat.S_ISDIR(visible.st_mode) or ( + opened.st_dev, opened.st_ino + ) != (visible.st_dev, visible.st_ino): + raise ValueError("output directory changed during export") + finally: + for fd in reversed(fds): + os.close(fd) + return root / path + +EXPECTED_CATALOGUE = json.loads( + "{\"profile\":\"MAT-SPEC-008\",\"version\":\"0.1.0\",\"scope\":\"Source-" + "pinned original helium-4 SVP temperature-series measurement " + "packets from at least two independent acquisitions; an artic" + "le citation, figure or fitted exponent is not an original me" + "asurement packet\",\"review_date\":\"2026-11-09\",\"numeric_source" + "\":\"MAT-SPEC-006 frozen 12-row Lipa-Chui 1984 Appendix A proc" + "essed calorimetry extract\",\"parent_fit_source\":\"MAT-SPEC-007" + " frozen four-row 2007 secondary review fit-summary table\",\"s" + "ource_docs\":[{\"doc_id\":\"LC83_NASA_1984\",\"document_kind\":\"ORI" + "GINAL_PROCESSED_MEASUREMENT_TABLE\",\"campaign\":\"LC83_SVP\",\"la" + "b_family\":\"STANFORD_LIPA\",\"primary_doi\":\"10.1103/PhysRevLett" + ".51.2291\",\"url\":\"https://ntrs.nasa.gov/citations/19860021083" + "\",\"source_bound_measurement_rows\":12,\"per_row_calibrated_unc" + "ertainty\":false,\"orthogonal_phase_diagnostic\":false,\"conditi" + "on\":\"HE4_SVP\",\"scope_note\":\"1984 NASA-CR-177037 original Lip" + "a-Chui gravity-corrected averaged table, not raw instrument " + "stream\"},{\"doc_id\":\"AHLERS_PRA_1971\",\"document_kind\":\"ORIGIN" + "AL_EXPERIMENT_PUBLICATION\",\"campaign\":\"AL71_SVP\",\"lab_family" + "\":\"BELL_AHLERS\",\"primary_doi\":\"10.1103/PhysRevA.3.696\",\"url\"" + ":\"https://doi.org/10.1103/PhysRevA.3.696\",\"source_bound_meas" + "urement_rows\":0,\"per_row_calibrated_uncertainty\":false,\"orth" + "ogonal_phase_diagnostic\":false,\"condition\":\"HE4_SVP\",\"scope_" + "note\":\"Original SVP calorimetry published; no per-row origin" + "al numeric data acquired and hash-pinned by this profile\"},{" + "\"doc_id\":\"MUELLER_PRB_1976\",\"document_kind\":\"MIXED_NEW_PRESS" + "URE_EXPERIMENT_AND_SVP_REANALYSIS\",\"campaign\":\"AL71_SVP\",\"la" + "b_family\":\"BELL_AHLERS\",\"primary_doi\":\"10.1103/PhysRevB.14.2" + "096\",\"url\":\"https://doi.org/10.1103/PhysRevB.14.2096\",\"sourc" + "e_bound_measurement_rows\":0,\"per_row_calibrated_uncertainty\"" + ":false,\"orthogonal_phase_diagnostic\":false,\"condition\":\"SVP_" + "FIT_FROM_AHLERS_PRIOR_DATA;NEW_PRESSURE_EXPANSION_OUTSIDE_SC" + "OPE\",\"scope_note\":\"Reports independent pressurized thermal-e" + "xpansion data too; SVP heat-capacity fit in MAT-SPEC-007 tra" + "ces earlier Ahlers measurement; not a new SVP calorimetry da" + "taset\"},{\"doc_id\":\"GASPARINI_MOLDOVER_PRB_1975\",\"document_ki" + "nd\":\"ORIGINAL_EXPERIMENT_PUBLICATION\",\"campaign\":\"GM75_SVP\"," + "\"lab_family\":\"MINNESOTA_GASPARINI_MOLDOVER\",\"primary_doi\":\"1" + "0.1103/PhysRevB.12.93\",\"url\":\"https://doi.org/10.1103/PhysRe" + "vB.12.93\",\"source_bound_measurement_rows\":0,\"per_row_calibra" + "ted_uncertainty\":false,\"orthogonal_phase_diagnostic\":false,\"" + "condition\":\"PURE_HE4_SVP_SUBSET_NOT_ACQUIRED\",\"scope_note\":\"" + "Original study includes pure helium-4 and 3He-4He mixtures; " + "no pure-4He source-bound original numeric rows admitted\"},{\"" + "doc_id\":\"GASPARINI_GAETA_PRB_1978\",\"document_kind\":\"REANALYS" + "IS\",\"campaign\":\"GM75_SVP\",\"lab_family\":\"MINNESOTA_GASPARINI_" + "MOLDOVER\",\"primary_doi\":\"10.1103/PhysRevB.17.1466\",\"url\":\"ht" + "tps://doi.org/10.1103/PhysRevB.17.1466\",\"source_bound_measur" + "ement_rows\":0,\"per_row_calibrated_uncertainty\":false,\"orthog" + "onal_phase_diagnostic\":false,\"condition\":\"HE4_SVP_FIT_REANAL" + "YSIS\",\"scope_note\":\"Fit reanalysis of earlier source measure" + "ments, not a new original SVP calorimeter acquisition\"},{\"do" + "c_id\":\"STS52_NASA_1994\",\"document_kind\":\"ORIGINAL_EXPERIMENT" + "_CONFERENCE\",\"campaign\":\"STS52_1992\",\"lab_family\":\"STANFORD_" + "LIPA\",\"primary_doi\":null,\"url\":\"https://ntrs.nasa.gov/citati" + "ons/19950007794\",\"source_bound_measurement_rows\":0,\"per_row_" + "calibrated_uncertainty\":false,\"orthogonal_phase_diagnostic\":" + "false,\"condition\":\"HE4_LAMBDA_MICROGRAVITY;RUN_LEVEL_CONDITI" + "ONS_NOT_PINNED\",\"scope_note\":\"1992 orbital experiment confer" + "ence summary; no primary per-row original data pinned\"},{\"do" + "c_id\":\"STS52_PRL_1996\",\"document_kind\":\"ORIGINAL_EXPERIMENT_" + "PUBLICATION\",\"campaign\":\"STS52_1992\",\"lab_family\":\"STANFORD_" + "LIPA\",\"primary_doi\":\"10.1103/PhysRevLett.76.944\",\"url\":\"http" + "s://doi.org/10.1103/PhysRevLett.76.944\",\"source_bound_measur" + "ement_rows\":0,\"per_row_calibrated_uncertainty\":false,\"orthog" + "onal_phase_diagnostic\":false,\"condition\":\"HE4_LAMBDA_MICROGR" + "AVITY\",\"scope_note\":\"1996 report of the 1992 orbital experim" + "ent, not a second orbital acquisition\"},{\"doc_id\":\"STS52_PRB" + "_2003\",\"document_kind\":\"REVISED_ANALYSIS_SAME_CAMPAIGN\",\"cam" + "paign\":\"STS52_1992\",\"lab_family\":\"STANFORD_LIPA\",\"primary_do" + "i\":\"10.1103/PhysRevB.68.174518\",\"url\":\"https://doi.org/10.11" + "03/PhysRevB.68.174518\",\"source_bound_measurement_rows\":0,\"pe" + "r_row_calibrated_uncertainty\":false,\"orthogonal_phase_diagno" + "stic\":false,\"condition\":\"HE4_SVP_MICROGRAVITY\",\"scope_note\":" + "\"2003 revised analysis of the STS-52 1992 experiment, not a " + "new acquisition; revised article describes raw experimental " + "error handling but source rows not pinned\"},{\"doc_id\":\"DONNE" + "LLY_BARENGHI_1998\",\"document_kind\":\"EVALUATED_COMPILATION\",\"" + "campaign\":null,\"lab_family\":null,\"primary_doi\":\"10.1063/1.55" + "6028\",\"url\":\"https://doi.org/10.1063/1.556028\",\"source_bound" + "_measurement_rows\":0,\"per_row_calibrated_uncertainty\":false," + "\"orthogonal_phase_diagnostic\":false,\"condition\":\"HE4_SVP_REC" + "OMMENDED_DATA_NOT_RAW\",\"scope_note\":\"MAT-SPEC-005 evaluated " + "recommended tables compile older experiments, not an indepen" + "dently sourced experimental campaign\"},{\"doc_id\":\"BARMATZ_RM" + "P_2007\",\"document_kind\":\"SECONDARY_FIT_REVIEW\",\"campaign\":nu" + "ll,\"lab_family\":null,\"primary_doi\":\"10.1103/RevModPhys.79.1\"" + ",\"url\":\"https://doi.org/10.1103/RevModPhys.79.1\",\"source_bou" + "nd_measurement_rows\":0,\"per_row_calibrated_uncertainty\":fals" + "e,\"orthogonal_phase_diagnostic\":false,\"condition\":\"HE4_SVP_F" + "IT_SUMMARIES_NOT_ROW_DATA\",\"scope_note\":\"MAT-SPEC-007 four f" + "itted parameter records are secondary review values from dis" + "tinct experiments, not raw row-level measurements\"}],\"noncla" + "im\":\"A different article or author is not measurement-level " + "independent reproduction; no per-row errors or independently" + " measured phase labels are admitted.\"}" +) +EXPECTED_SPEC = json.loads( + "{\"profile\":\"MAT-SPEC-008\",\"version\":\"0.1.0\",\"parent_profile\"" + ":\"MAT-SPEC-007 v0.1.0\",\"parent_merge_commit\":\"b97348ff8fcf3f" + "57764dec21a8914f153f96a745\",\"foundational_mat_spec_001_doi\":" + "\"10.5281/zenodo.24062652\",\"source_catalogue\":\"data/materials" + "/helium4/mat_spec_008_source_catalogue.json\",\"source_of_nume" + "rical_rows\":\"MAT-SPEC-006 SHA-pinned original processed Lipa" + "-Chui table\",\"review_fit_source\":\"MAT-SPEC-007 SHA-pinned se" + "condary fit table\",\"min_independent_measurement_campaigns\":2" + ",\"require_source_bound_rows\":true,\"require_measurement_level" + "_uncertainty\":true,\"require_orthogonal_diagnostic\":true,\"req" + "uire_lineage_verified_no_shared_run\":true,\"candidate_output\"" + ":\"STRUCTURAL_ONLY_UNAUTHENTICATED at best; never label it em" + "pirical admission\",\"physical_results\":\"NO_PHASE_CLASSIFIER_N" + "O_HOLDOUT_ACCURACY_NO_RAW_INDEPENDENT_REPLICATION\",\"runtime_" + "artifacts\":\"canonical JSON/CSV symbolic evidence only, no au" + "dio PCM WAV MIDI playback\",\"future\":\"MAT-SPEC-009 only if th" + "is gate admits adequate independent campaigns; MAT-SPEC-010 " + "closes numbered series; SPARK/Ada and Lean/ECMA after 010\"}" +) diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-drift/materials/mat_spec_009.py b/formal/sonification/mat009/audit/verification-probe-001/source-drift/materials/mat_spec_009.py new file mode 100644 index 0000000..80941a2 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-drift/materials/mat_spec_009.py @@ -0,0 +1,541 @@ +"""MAT-SPEC-009: preregistered-future protocol and synthetic gate stress. + +SPDX-License-Identifier: MPL-2.0 +Copyright (c) 2026 Trent Slade / QSOL-IMC. + +No independent experimental holdout is available. All executable fixtures +are synthetic, explicitly denied physical admission, never scored as physics. +No sampled audio, PCM or waveform buffers in memory or persisted. +""" +from __future__ import annotations + +import csv +import io +import json +import os +import re +import stat +from contextlib import suppress +from pathlib import Path, PurePosixPath + +from materials import mat_spec, mat_spec_008 + +PROFILE = "MAT-SPEC-009" +VERSION = "0.1.0" +PARENT_COMMIT = "b4247877dd471e2e9d4986c86bdc1f11b14e43f8" +FOUNDATIONAL_DOI = "10.5281/zenodo.24062652" +SPEC_PATH = "spec/mat-spec-009.v0.1.json" +IMPLEMENTATION_PATHS = ( + "materials/mat_spec_009.py", "scripts/build_mat_spec_009.py", +) +OUTPUT_NAMES = frozenset({ + "contract.json", "source-gate.json", "split-protocol.json", + "synthetic-controls.csv", "receiver-gate.json", "audit.json", + "manifest.json", +}) +EXPECTED_SOURCE_STATUS = "BLOCKED_INSUFFICIENT_INDEPENDENT_MEASUREMENT_DATA" +CONTROL_IDS = ( + "SYNTHETIC_CANDIDATE_DENIED", + "CROSS_CAMPAIGN_RUN_REUSE", + "CAMPAIGN_SPLIT_LEAKAGE", + "SOURCE_BYTES_REUSED", + "TEMPERATURE_DERIVED_LABEL", + "ZERO_MEASUREMENT_SIGMA", + "ORTHOGONAL_DIAGNOSTIC_ABSENT", + "DIAGNOSTIC_SOURCE_EQUALS_MEASUREMENT", + "UNDECLARED_RECEIVER_SCALE", + "MISSING_PROSPECTIVE_REGISTRATION", + "MIXED_PHYSICAL_PRESSURE", + "HOLDOUT_MISSING_PHASE", + "DERIVED_FIT_AS_MEASUREMENT", + "DOCUMENT_REUSED", +) +SHA256_RE = re.compile(r"[0-9a-f]{64}") +# Frozen eight-output MAT-SPEC-008 baseline reconstructed at its merge SHA. +PARENT_V8_SHA256 = { + "admission.json": "ea1c960c6a6b20a58ae8895345f404d2028e7f3298a25aa871d0aea8e4cf769c", + "campaigns.csv": "5a052673e4c26a5c6cedc46aaabdfd113854419754b1f4ed36c37b9f1adbc16e", + "candidate-pairs.csv": ( + "47df30686f0bcb616a2eb1fca4073d55f6c96f419bcb36e42043acb8c12bfd98" + ), + "contract.json": "d5be6f36e8e931d15f427232268738eea7f2ba5f268f1a29895f4e98048d6621", + "manifest.json": "10d3cde4a68f13facf7badc71bc6e872f17bf632311284943ed8db3c3a913b5e", + "measurement-audit.json": ( + "4f80ef1fb48c66dc7e002333911386ef1ae869c3a458be9b583c8f943b3eac9c" + ), + "protocol.json": "6b4fa2721777b8ea51387782e7707056c0820885a99162dd400892c0629ff9ce", + "source-catalogue.json": ( + "c6d3fec5fc0179df2abbac51219956a6a79af82c327be34b76c359f5ec9de88e" + ), +} + + +def source_gate(parent: dict[str, bytes]) -> dict: + """Read the real, unchanged 008 negative admission, never invent a sample.""" + record = json.loads(parent["admission.json"]) + audit = json.loads(parent["measurement-audit.json"]) + if ( + record["status"] != EXPECTED_SOURCE_STATUS + or record["independent_measurement_campaigns_with_source_pinned_rows"] != 1 + or record["independent_measurement_campaign_pair_count"] != 0 + or record["independently_verified_raw_acquisition_campaigns"] != 0 + or record["physical_phase_accuracy"] is not None + or record["source_separated_heldout_accuracy"] is not None + or record["trained_phase_classifier"] is not False + or audit["available_row_level_calibrated_uncertainties"] != 0 + or audit["available_independent_phase_diagnostic_rows"] != 0 + or audit["original_source_pinned_processed_measurement_campaigns"] != 1 + or audit["source_pinned_processed_measurement_rows"] != 12 + ): + raise ValueError("unexpected MAT-SPEC-008 independent evidence admission drift") + return { + "input_profile": "MAT-SPEC-008", "parent_status": record["status"], + "source_pinned_processed_campaigns": 1, + "source_pinned_processed_rows": 12, + "independent_measurement_pairs": 0, + "calibrated_uncertainty_rows": 0, + "independent_diagnostic_rows": 0, + "physical_evidence_admitted": False, + "challenge_enabled_for_real_measurements": False, + "source_gate_reason": "NO_INDEPENDENT_SOURCE_SEPARATED_MEASUREMENT_CORPUS", + } + + +def _identifier(value: object) -> bool: + return ( + isinstance(value, str) + and len(value) <= 100 + and re.fullmatch(r"[A-Z0-9_]+", value) is not None + ) + + +def _digest(value: object) -> bool: + return isinstance(value, str) and SHA256_RE.fullmatch(value) is not None + + +def check_future_challenge(records: object) -> dict: + """Structural-only source-family split check, never empirical certification. + + Input identity, metadata and hashes are user assertions. They are NOT a + verified original acquisition or independently audited preregistration. + """ + if not isinstance(records, list) or not records or len(records) > 10000: + return { + "status": "BLOCKED", + "reasons": ["EMPTY_OR_MALFORMED_CHALLENGE"], + "physical_evidence_admitted": False, + "independence_authenticated": False, + "heldout_accuracy": None, + } + parent = mat_spec_008.validate_future_measurement_packet(records) + reasons = set(parent["reasons"]) + split_by_campaign: dict[str, str] = {} + campaigns_by_split: dict[str, set[str]] = { + "TRAIN": set(), "HOLDOUT": set(), + } + labs_by_split: dict[str, set[str]] = { + "TRAIN": set(), "HOLDOUT": set(), + } + phases_by_split: dict[str, set[str]] = { + "TRAIN": set(), "HOLDOUT": set(), + } + seen_registration: set[str] = set() + # Distinguish a shared diagnostic *document within one campaign* from + # a diagnostic source or event replayed by a different acquisition. + diagnostic_hash_owners: dict[str, tuple[str, str]] = {} + diagnostic_event_owners: dict[str, tuple[str, str]] = {} + for record in records: + if not isinstance(record, dict): + reasons.add("MALFORMED_CANDIDATE_RECORD") + continue + role = record.get("study_role") + if role not in ("TRAIN", "HOLDOUT"): + reasons.add("UNDECLARED_TRAIN_HOLDOUT_ROLE") + continue + campaign, lab = record.get("campaign_id"), record.get("lab_family_id") + if not _identifier(campaign) or not _identifier(lab): + reasons.add("MISSING_EXPERIMENT_FAMILY_IDENTITY") + continue + if campaign in split_by_campaign and split_by_campaign[campaign] != role: + reasons.add("CAMPAIGN_CROSSES_TRAIN_HOLDOUT_MUTANT") + split_by_campaign[campaign] = role + campaigns_by_split[role].add(campaign) + labs_by_split[role].add(lab) + phase = record.get("phase") + if isinstance(phase, str) and phase in ("HE_I", "HE_II"): + phases_by_split[role].add(phase) + if ( + record.get("measurement_quantity") != "HEAT_CAPACITY" + or record.get("measurement_unit") != "J_PER_MOL_K" + ): + reasons.add("INCOMMENSURATE_MEASUREMENT_UNITS") + if record.get("pressure_condition") != "HE4_SVP": + reasons.add("UNDECLARED_PRESSURE_CONDITION") + if record.get("receiver_scale") != "5": + reasons.add("UNDECLARED_RECEIVER_SCALE") + if record.get("label_basis") != "ORTHOGONAL_DIAGNOSTIC": + reasons.add("CIRCULAR_OR_MISSING_ORTHOGONAL_LABEL") + diagnostic_hash = record.get("diagnostic_sha256") + diagnostic_event_id = record.get("diagnostic_event_id") + source_hash = record.get("source_sha256") + if ( + not _digest(diagnostic_hash) or diagnostic_hash == source_hash + or not _identifier(diagnostic_event_id) + ): + reasons.add("INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED") + # Check both provenance dimensions independently. Different phase + # observations may share a diagnostic document *within* a campaign, + # but neither its digest nor an event identity may be recycled by + # another campaign or across TRAIN and HOLDOUT. + for identity, registry, valid in ( + (diagnostic_hash, diagnostic_hash_owners, _digest(diagnostic_hash)), + ( + diagnostic_event_id, + diagnostic_event_owners, + _identifier(diagnostic_event_id), + ), + ): + if not valid: + continue + prior = registry.setdefault(identity, (campaign, role)) + if prior[0] != campaign: + reasons.add("DIAGNOSTIC_PROVENANCE_REUSED_ACROSS_CAMPAIGNS") + if prior[1] != role: + reasons.add("DIAGNOSTIC_PROVENANCE_LEAKAGE_ACROSS_SPLITS") + receipt = record.get("pre_registration_sha256") + if not _digest(receipt): + reasons.add("MISSING_PROSPECTIVE_REGISTRATION_RECEIPT") + else: + seen_registration.add(receipt) + if len(seen_registration) != 1: + reasons.add("INCONSISTENT_PREREGISTRATION_RECEIPT") + if not campaigns_by_split["TRAIN"] or not campaigns_by_split["HOLDOUT"]: + reasons.add("BOTH_EXPERIMENT_SPLITS_REQUIRED") + if (campaigns_by_split["TRAIN"] & campaigns_by_split["HOLDOUT"] + or labs_by_split["TRAIN"] & labs_by_split["HOLDOUT"]): + reasons.add("SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS") + for role in ("TRAIN", "HOLDOUT"): + if phases_by_split[role] != {"HE_I", "HE_II"}: + reasons.add(role + "_REQUIRES_BOTH_PHASES") + # The existing parent gate catches reused run IDs, documents and hashes. + # Even a passing structural check cannot authenticate source independence. + outcome = sorted(reasons) + return { + "status": "BLOCKED" if outcome else "STRUCTURAL_ONLY_UNAUTHENTICATED", + "reasons": outcome, + "train_campaigns": len(campaigns_by_split["TRAIN"]), + "heldout_campaigns": len(campaigns_by_split["HOLDOUT"]), + "physical_evidence_admitted": False, + "independence_authenticated": False, + "heldout_accuracy": None, + "trained_classifier": False, + "meaning": ( + "Synthetic or self-declared metadata never establishes " + "external physical validation" + ), + } + + +def _synthetic_controls() -> list[dict]: + """Synthetic, in-memory-only metadata fixtures with no physical authority.""" + records = [] + for campaign, lab, run, digest, diag, role in ( + ("SYNTH_TRAIN", "SYNTH_LAB_A", "SYNTH_RUN_A", "a" * 64, "c" * 64, "TRAIN"), + ("SYNTH_HELD", "SYNTH_LAB_B", "SYNTH_RUN_B", "b" * 64, "d" * 64, "HOLDOUT"), + ): + for phase in ("HE_I", "HE_II"): + records.append({ + "row_id": campaign + "_" + phase, + "campaign_id": campaign, "lab_family_id": lab, + "original_run_id": run, + "source_document_id": "DOC_" + campaign, + "source_sha256": digest, + "diagnostic_sha256": diag, + "diagnostic_event_id": "DIAG_" + campaign + "_" + phase, + "source_type": "ORIGINAL_EXPERIMENTAL_RECORD", + "measurement_quantity": "HEAT_CAPACITY", + "measurement_unit": "J_PER_MOL_K", + "measurement_value": "12.34", + "measurement_sigma": "0.01", + "diagnostic_sigma": "0.02", + "diagnostic_basis": "INDEPENDENT_NON_TEMPERATURE_DIAGNOSTIC", + "label_basis": "ORTHOGONAL_DIAGNOSTIC", + "phase": phase, + "receiver_scale": "5", + "pre_registration_sha256": "e" * 64, + "pressure_condition": "HE4_SVP", + "study_role": role, + "synthetic_fixture": True, + }) + return records + + +def negative_controls() -> list[dict]: + """Execute negative controls, recording only expected/observed error IDs. + + Never expose synthetic rows as experimental measurements or score them. + """ + controls = ( + ("SYNTHETIC_CANDIDATE_DENIED", "SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT"), + ("CROSS_CAMPAIGN_RUN_REUSE", "REUSED_ORIGINAL_RUN_ACROSS_CAMPAIGNS"), + ("CAMPAIGN_SPLIT_LEAKAGE", "CAMPAIGN_CROSSES_TRAIN_HOLDOUT"), + ("SOURCE_BYTES_REUSED", "REUSED_SOURCE_BYTES_ACROSS_CAMPAIGNS"), + ("TEMPERATURE_DERIVED_LABEL", "CIRCULAR_OR_MISSING_PHASE_DIAGNOSTIC"), + ("ZERO_MEASUREMENT_SIGMA", "MISSING_CALIBRATED_MEASUREMENT_UNCERTAINTY"), + ("ORTHOGONAL_DIAGNOSTIC_ABSENT", "INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED"), + ("DIAGNOSTIC_SOURCE_EQUALS_MEASUREMENT", "INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED"), + ("UNDECLARED_RECEIVER_SCALE", "UNDECLARED_RECEIVER_SCALE"), + ("MISSING_PROSPECTIVE_REGISTRATION", "MISSING_PROSPECTIVE_REGISTRATION_RECEIPT"), + ("MIXED_PHYSICAL_PRESSURE", "UNDECLARED_PRESSURE_CONDITION"), + ("HOLDOUT_MISSING_PHASE", "HOLDOUT_REQUIRES_BOTH_PHASES"), + ("DERIVED_FIT_AS_MEASUREMENT", "DERIVED_FIT_OR_COMPILATION_IS_NOT_PRIMARY_DATA"), + ("DOCUMENT_REUSED", "REUSED_ORIGINAL_DOCUMENT_ACROSS_CAMPAIGNS"), + ) + if tuple(x[0] for x in controls) != CONTROL_IDS: + raise ValueError("frozen negative control order mismatch") + results = [] + for control_id, expected_reason in controls: + rows = _synthetic_controls() + if control_id == "CROSS_CAMPAIGN_RUN_REUSE": + for row in rows[2:]: + row["original_run_id"] = "SYNTH_RUN_A" + elif control_id == "CAMPAIGN_SPLIT_LEAKAGE": + rows[1]["study_role"] = "HOLDOUT" + elif control_id == "SOURCE_BYTES_REUSED": + for row in rows[2:]: + row["source_sha256"] = "a" * 64 + elif control_id == "TEMPERATURE_DERIVED_LABEL": + rows[0]["diagnostic_basis"] = "TEMPERATURE_THRESHOLD" + elif control_id == "ZERO_MEASUREMENT_SIGMA": + rows[0]["measurement_sigma"] = "0" + elif control_id == "ORTHOGONAL_DIAGNOSTIC_ABSENT": + rows[0]["diagnostic_sha256"] = None + elif control_id == "DIAGNOSTIC_SOURCE_EQUALS_MEASUREMENT": + rows[0]["diagnostic_sha256"] = "a" * 64 + elif control_id == "UNDECLARED_RECEIVER_SCALE": + rows[0]["receiver_scale"] = "10" + elif control_id == "MISSING_PROSPECTIVE_REGISTRATION": + rows[0]["pre_registration_sha256"] = "" + elif control_id == "MIXED_PHYSICAL_PRESSURE": + rows[0]["pressure_condition"] = "DOCUMENTED_FIXED_PRESSURE" + elif control_id == "HOLDOUT_MISSING_PHASE": + rows[3]["phase"] = "HE_I" + rows[3]["row_id"] = "SYNTH_HELD_SECOND_HE_I" + elif control_id == "DERIVED_FIT_AS_MEASUREMENT": + rows[0]["source_type"] = "REANALYSIS" + elif control_id == "DOCUMENT_REUSED": + for row in rows[2:]: + row["source_document_id"] = "DOC_SYNTH_TRAIN" + outcome = check_future_challenge(rows) + if ( + outcome["status"] != "BLOCKED" + or expected_reason not in outcome["reasons"] + or "SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT" not in outcome["reasons"] + or outcome["physical_evidence_admitted"] is not False + or outcome["heldout_accuracy"] is not None + ): + raise ValueError("synthetic negative control failed: " + control_id) + results.append({ + "control_id": control_id, + "synthetic_only": "true", + "expected_rejection": expected_reason, + "observed_rejection": expected_reason, + "result": "PASS_REJECTED", + "physical_evidence_admitted": "false", + "classifier_accuracy": "NULL", + }) + return results + + +def _csv(rows: list[dict]) -> bytes: + if not rows: + raise ValueError("empty result table") + buff = io.StringIO(newline="") + writer = csv.DictWriter( + buff, fieldnames=list(rows[0]), lineterminator="\n" + ) + writer.writeheader() + writer.writerows(rows) + return buff.getvalue().encode("ascii") + + +def build_evidence(root: Path) -> dict[str, bytes]: + """Rebuild original eight profiles and preserve their exact identities.""" + parent = mat_spec_008.build_evidence(root) + if set(parent) != mat_spec_008.OUTPUT_NAMES: + raise ValueError("MAT-SPEC-008 parent membership mismatch") + parents = {name: mat_spec.sha256(raw) for name, raw in parent.items()} + if parents != PARENT_V8_SHA256: + raise ValueError("frozen MAT-SPEC-008 outputs drifted") + prior = json.loads(parent["manifest.json"]) + if ( + prior.get("profile") != "MAT-SPEC-008" + or prior.get("version") != "0.1.0" + or prior.get("parent_commit") != mat_spec_008.PARENT_COMMIT + or prior.get("foundational_mat_spec_001_doi") != FOUNDATIONAL_DOI + ): + raise ValueError("MAT-SPEC-008 ancestor identity mismatch") + if set(prior["outputs"]) != set(parent) - {"manifest.json"} or any( + mat_spec.sha256(parent[name]) != record["sha256"] + for name, record in prior["outputs"].items() + ): + raise ValueError("ancestor output manifest inconsistency") + source = source_gate(parent) + spec_raw = mat_spec.read_regular(root / SPEC_PATH) + try: + contract = json.loads(spec_raw) + except (ValueError, UnicodeDecodeError) as exc: + raise ValueError("MAT-SPEC-009 contract malformed") from exc + if contract != EXPECTED_SPEC: + raise ValueError("MAT-SPEC-009 prospective protocol drift") + controls = negative_controls() + if len(controls) != len(CONTROL_IDS): + raise ValueError("synthetic control membership drift") + split = { + "profile": PROFILE, "version": VERSION, + "status": "BLOCKED_NO_ADMITTED_SOURCE_SEPARATED_PHYSICAL_EVIDENCE", + "source_gate": source["parent_status"], + "split_unit": "original independent acquisition campaign", + "prospective_protocol": True, + "retrospectively_preregistered_for_mat_spec_006_008": False, + "training_campaigns": 0, "heldout_campaigns": 0, + "physical_records_assigned": 0, + "synthetic_rows_admitted_as_physics": 0, + "classifier_trained": False, "holdout_accuracy": None, + "physical_evidence_admitted": False, + "evaluation_performed": "SYNTHETIC_NEGATIVE_CONTROLS_ONLY", + } + receiver = { + "status": "UNEXECUTED_FOR_PHYSICAL_CLASSIFICATION", + "authored_scale": "5 Hz per J/(mol K)", + "exact_source_math": "Fraction", + "receiver": "nearest 12-TET note, symbolic only", + "receiver_scale_tuned_on_holdout": False, + "physical_performance": None, + "quantized_source_separated_accuracy": None, + "sampled_audio_generated": False, + } + audit = { + "profile": PROFILE, "version": VERSION, + "synthetic_negative_controls_executed": len(controls), + "synthetic_negative_controls_passed": len(controls), + "source_pinned_measurement_campaigns": 1, + "eligible_independent_campaign_pairs": 0, + "physical_validation_experiments_performed": 0, + "phase_classifier_accuracy": None, + "synthetic_accuracy_reported_as_physics": False, + "program_stop": "MAT-SPEC-010", + } + outputs = { + "contract.json": mat_spec.canonical_json(contract), + "source-gate.json": mat_spec.canonical_json(source), + "split-protocol.json": mat_spec.canonical_json(split), + "synthetic-controls.csv": _csv(controls), + "receiver-gate.json": mat_spec.canonical_json(receiver), + "audit.json": mat_spec.canonical_json(audit), + } + impl = { + path: mat_spec.sha256(mat_spec.read_regular(root / path)) + for path in IMPLEMENTATION_PATHS + } + manifest = { + "profile": PROFILE, "version": VERSION, + "parent_commit": PARENT_COMMIT, + "parent_artifacts": { + name: {"sha256": digest, "bytes": len(parent[name])} + for name, digest in sorted(parents.items()) + }, + "contract": {"path": SPEC_PATH, "sha256": mat_spec.sha256(spec_raw)}, + "implementation": impl, + "outputs": { + name: {"sha256": mat_spec.sha256(data), "bytes": len(data)} + for name, data in sorted(outputs.items()) + }, + "foundational_mat_spec_001_doi": FOUNDATIONAL_DOI, + "canonical": "ASCII sorted compact JSON LF and CSV LF, no clock", + "manifest_self_hash": None, + "canonical_pcm_sha256": None, + "canonical_wav_sha256": None, + "audio_generated": False, + } + outputs["manifest.json"] = mat_spec.canonical_json(manifest) + return outputs + + +def write_evidence(root: Path, destination: str, products: dict[str, bytes]) -> Path: + """POSIX no-follow exclusive directory export, JSON/CSV only.""" + path = PurePosixPath(destination) + if ( + not destination or path.is_absolute() or "\\" in destination + or any(piece in {"", ".", ".."} for piece in destination.split("/")) + ): + raise ValueError("output must be a fresh relative directory") + if set(products) != OUTPUT_NAMES or any( + PurePosixPath(name).name != name + or Path(name).suffix not in {".csv", ".json"} for name in products + ): + raise ValueError("non-symbolic runtime output is forbidden") + flags = os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW + fds = [os.open(root, flags)] + try: + for part in path.parts[:-1]: + with suppress(FileExistsError): + os.mkdir(part, mode=0o755, dir_fd=fds[-1]) + fds.append(os.open(part, flags, dir_fd=fds[-1])) + parent_fd = fds[-1] + os.mkdir(path.parts[-1], mode=0o755, dir_fd=parent_fd) + fds.append(os.open(path.parts[-1], flags, dir_fd=parent_fd)) + out = fds[-1] + for name in sorted(products): + fd = os.open( + name, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, + mode=0o644, dir_fd=out, + ) + with os.fdopen(fd, "wb") as target: + target.write(products[name]) + opened = os.fstat(out) + visible = os.stat(path.parts[-1], dir_fd=parent_fd, follow_symlinks=False) + if not stat.S_ISDIR(visible.st_mode) or ( + opened.st_dev, opened.st_ino + ) != (visible.st_dev, visible.st_ino): + raise ValueError("output directory changed during export") + finally: + for fd in reversed(fds): + os.close(fd) + return root / path + +EXPECTED_SPEC = json.loads( + "{\"profile\":\"MAT-SPEC-009\",\"version\":\"0.1.0\",\"parent_profile\"" + ":\"MAT-SPEC-008 v0.1.0\",\"parent_merge_commit\":\"b4247877dd471e" + "2e9d4986c86bdc1f11b14e43f8\",\"foundational_mat_spec_001_doi\":" + "\"10.5281/zenodo.24062652\",\"research_question\":\"Can a frozen " + "symbolic receiver preserve independently measured helium-I a" + "nd helium-II phase evidence on a source-separated experiment" + " holdout?\",\"protocol_status\":\"PROSPECTIVE_FOR_FUTURE_ACQUISI" + "TIONS_ONLY\",\"timing\":\"Document frozen after examining MAT-SP" + "EC-001 through MAT-SPEC-008 data; not a retrospective prereg" + "istration for prior experiments\",\"predecessor_gate_required\"" + ":\"INDEPENDENT_MEASUREMENTS_ADMITTED\",\"source_separation_unit" + "\":\"original independent acquisition campaign; never split re" + "cords within a campaign\",\"partition\":\"explicit TRAIN or HOLD" + "OUT; two families, one campaign minimum in each; both phases" + " per partition\",\"admissible_observable\":\"HE4_SVP heat_capaci" + "ty J_PER_MOL_K; positive calibrated per-row uncertainties; i" + "ndependent non-temperature phase diagnostics with distinct s" + "ource SHA\",\"receiver\":\"Fraction-preserving authored symbolic" + " 5 Hz per J/(mol K), quantize only after exact mapping; scal" + "e fixed before training and never tuned on holdout\",\"metrics" + "\":\"reserved: predeclared source-family-separated confusion m" + "atrix and discrimination with uncertainty, only after physic" + "al admission; no scores in this release\",\"nonclaims\":\"NO_REA" + "L_PHASE_CLASSIFIER_NO_INDEPENDENT_HOLDOUT_NO_EXPERIMENTAL_AC" + "CURACY_NO_LISTENER_RESULT\",\"synthetic_policy\":\"negative cont" + "rols only; all synthetic fixtures are explicitly rejected as" + " physical data, never included as empirical accuracy\",\"prosp" + "ective_registration\":\"future external registered receipt mus" + "t be independently verified, a candidate SHA alone never cer" + "tifies preregistration\",\"output_policy\":\"canonical ASCII JSO" + "N and CSV; no sampled waveform PCM WAV or playback\",\"program" + "_stop\":\"MAT-SPEC-010 is final; SPARK/Ada and VANILLAJS Lean-" + "ECMA afterwards\"}" +) diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/receipt.json b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/receipt.json new file mode 100644 index 0000000..3a6b9c8 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/receipt.json @@ -0,0 +1,36 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_sonification_formal_mat009_split.py", + "-q" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:52:28.982815+00:00", + "ended_utc": "2026-11-10T00:52:29.350500+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "DIRTY", + "inputs": { + "tests/test_sonification_formal_mat009_split.py": "beb02ce17f07807309e9cceba2a9e0dd6412dc578cc8362050890f38a5bdad73", + "formal/sonification/mat009/source/SOURCE_BINDING.json": "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_sha256": "a9483ce54e9021f19fa52d97950324449ba5ca38db4a3470dd71bef8a85d2de7", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/stdout.log b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/stdout.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/tracked-diff.patch b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/worktree-status.txt b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/worktree-status.txt new file mode 100644 index 0000000..9c54d09 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-finite-001/worktree-status.txt @@ -0,0 +1,2 @@ +?? formal/sonification/evidence/mat009-source-bind-001/ +?? formal/sonification/mat009/lean/ diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/receipt.json b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/receipt.json new file mode 100644 index 0000000..813b10b --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/receipt.json @@ -0,0 +1,34 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "-m", + "pytest", + "-q", + "tests/test_sonification_formal_mat009_split.py", + "tests/test_mat_spec_009.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:52:36.645752+00:00", + "ended_utc": "2026-11-10T00:52:54.847548+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "DIRTY", + "inputs": { + "tests/test_sonification_formal_mat009_split.py": "beb02ce17f07807309e9cceba2a9e0dd6412dc578cc8362050890f38a5bdad73", + "tests/test_mat_spec_009.py": "b6041d67615c4203d435250bdc97403e61ca371e0c8f20f8abdeda69251ccbf8", + "formal/sonification/mat009/source/SOURCE_BINDING.json": "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "d9cc08981d877d35bc68dd5572cb02a6c909d5ee70d9539d37aef89383b86bff", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/stderr.log b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/stdout.log b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/stdout.log new file mode 100644 index 0000000..4813857 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/stdout.log @@ -0,0 +1,2 @@ +................................... [100%] +35 passed, 36 subtests passed in 18.01s diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/tracked-diff.patch b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/worktree-status.txt b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/worktree-status.txt new file mode 100644 index 0000000..40e4879 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-pytest-001/worktree-status.txt @@ -0,0 +1,4 @@ +?? formal/sonification/evidence/mat009-finite-001/ +?? formal/sonification/evidence/mat009-ruff-source-001/ +?? formal/sonification/evidence/mat009-source-bind-001/ +?? formal/sonification/mat009/lean/ diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/receipt.json b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/receipt.json new file mode 100644 index 0000000..9566d9d --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/receipt.json @@ -0,0 +1,37 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "uv", + "run", + "--no-project", + "--offline", + "--with", + "ruff", + "ruff", + "check", + "formal/sonification/mat009/source/source_bind.py", + "tests/test_sonification_formal_mat009_split.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:52:33.144223+00:00", + "ended_utc": "2026-11-10T00:52:33.170994+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "DIRTY", + "inputs": { + "formal/sonification/mat009/source/source_bind.py": "575ab1ea12186419bc6dbae31e12ae1e45d46a3b3c4a630b63e0a53853433beb", + "tests/test_sonification_formal_mat009_split.py": "beb02ce17f07807309e9cceba2a9e0dd6412dc578cc8362050890f38a5bdad73" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/home/trent/.local/bin/uv", + "command_executable_sha256": "92face6b1f0462ad911857957bd168cd4ae45515e2a2cb3fcc3ecbda3d4d82b1", + "stdout_sha256": "82b3e6a6c090a57601d22943bd23fca9218d1031dbe5a7b754092f9a156b4f18", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/stderr.log b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/stdout.log b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/stdout.log new file mode 100644 index 0000000..1f5f344 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/stdout.log @@ -0,0 +1 @@ +All checks passed! diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/tracked-diff.patch b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/worktree-status.txt b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/worktree-status.txt new file mode 100644 index 0000000..f6c6f53 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-ruff-source-001/worktree-status.txt @@ -0,0 +1,3 @@ +?? formal/sonification/evidence/mat009-finite-001/ +?? formal/sonification/evidence/mat009-source-bind-001/ +?? formal/sonification/mat009/lean/ diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/receipt.json b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/receipt.json new file mode 100644 index 0000000..cceecbe --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/receipt.json @@ -0,0 +1,29 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "formal/sonification/mat009/source/source_bind.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:51:31.900841+00:00", + "ended_utc": "2026-11-10T00:51:31.949116+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "CLEAN", + "inputs": { + "formal/sonification/mat009/source/source_bind.py": "575ab1ea12186419bc6dbae31e12ae1e45d46a3b3c4a630b63e0a53853433beb", + "formal/sonification/mat009/source/SOURCE_BINDING.json": "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "5a3750fcbab24ba5889a7a5439b5445d7484ac50a497ab546df22139462902b7", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/stderr.log b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/stdout.log b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/stdout.log new file mode 100644 index 0000000..631c1d9 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/stdout.log @@ -0,0 +1 @@ +{"assurance": "SOURCE_SYNTAX_PINNED_ONLY", "commit": "0758a96360726aafbb07abed34620eda178407ae", "direct_parent_sha256": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", "refinement_to_cpython": "OPEN", "selected_functions": 8, "status": "SOURCE_SYNTAX_MATCH", "tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", "target_sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", "tree": "a6a03e1227e666680d656b886201ee9dde9de32d"} diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/tracked-diff.patch b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/worktree-status.txt b/formal/sonification/mat009/audit/verification-probe-001/source-receipts/mat009-source-bind-001/worktree-status.txt new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/checker-result/result.json b/formal/sonification/mat009/audit/verification-probe-002/checker-result/result.json new file mode 100644 index 0000000..4221c53 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/checker-result/result.json @@ -0,0 +1,11 @@ +{ + "AUDIT_ACCEPTED": "OPEN", + "DIFFERENTIAL_TESTED": "NOT_EXECUTED", + "MODEL_PROVED": "NOT_EXECUTED", + "REFINEMENT_PROVED": "OPEN", + "baseline_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "completed_utc": "2026-11-10T01:13:44.036729+00:00", + "error": "stale proof input: SplitModel.lean", + "started_utc": "2026-11-10T01:13:44.032184+00:00", + "status": "FAIL" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/EVIDENCE_MANIFEST.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/EVIDENCE_MANIFEST.json new file mode 100644 index 0000000..6dec709 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/EVIDENCE_MANIFEST.json @@ -0,0 +1,30 @@ +{ + "files_sha256": { + "build-00-SplitModel.json": "34ce5cf3d1dc2c4f740ea0360be7eaeec34e619315b63cec306d04e58076115c", + "build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.json": "5fccb56c651f29766987206416ba9d02ea3b95b4bd43f0ee67d1d8a0854203fd", + "build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.json": "d55c0693f763865b7ebc254fbd86ec266e650e93e146cea17407b465ecded54e", + "build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "build-03-ExactTypes.json": "71ff2627b1b9224d97347d827e310a1c73d5f2ab9fa3113ec1e03ecb4e870780", + "build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.json": "50a6752ba2f65a5cea9a1cb436cef3fdda1b5ea8122cd9a15dd255e7b85cc392", + "build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.stdout": "21d9dcb639ded4b2c3047045038ff0d3a3c216f2c1f57554d0832fb81e7042cc", + "declarations.json": "b3b5211e5edbbf49ac083f520bede6fef89ac3faccfa93b1d563e710f5f2537f", + "lean-version.json": "891fd7e9d7ca7393779b1eafec93925d0eb39390da8bb66ed47d2d72a5bd8d5b", + "lean-version.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "lean-version.stdout": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b", + "named-axioms.json": "d726df048cf1d5d7528afe2838eaa8a05b31b6a10c3b2a34109380b4bf779b1f", + "result.json": "74ed460c20a7ddc98d53891fc3a34de63404169f40405fe08fbcac2e4b6d85b1", + "theorem-types.json": "8ebc9839c12845f0410085754b475d7dd0ebf6c218869eebe39f2484104ddf5b", + "toolchain-imports.json": "69c9e85cad9c3ec024130bd80dc3e1fa6351053f135304268741bf1f0fd1b2ad" + }, + "proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "schema": "sonification-mat009-lean-evidence-v1", + "scope": "checked eligible-row mathematical models; CPython refinement OPEN" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-00-SplitModel.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-00-SplitModel.json new file mode 100644 index 0000000..4bdb01e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-00-SplitModel.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-01-DiagnosticFirstOwner.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-01-DiagnosticFirstOwner.json new file mode 100644 index 0000000..0550d4e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-01-DiagnosticFirstOwner.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-02-TypedConsumer.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-02-TypedConsumer.json new file mode 100644 index 0000000..ca5d4d0 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-02-TypedConsumer.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-03-ExactTypes.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-03-ExactTypes.json new file mode 100644 index 0000000..68500a4 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-03-ExactTypes.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-04-LeanAudit.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-04-LeanAudit.json new file mode 100644 index 0000000..16c555a --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-04-LeanAudit.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-hnntwcpn/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "21d9dcb639ded4b2c3047045038ff0d3a3c216f2c1f57554d0832fb81e7042cc", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-04-LeanAudit.stdout new file mode 100644 index 0000000..cbccb8f --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/build-04-LeanAudit.stdout @@ -0,0 +1,1664 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.initial","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._closed_1._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.initial._elambda_1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.initial.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_3","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_4","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRow","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._closed_1._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.lastRole [] x = none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_2._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.leakageReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.leakageReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.noParent","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.noParent x = False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.noParent.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout ∧\n s.campaigns MAT009.Role.train \"SAME\" ∧ s.campaigns MAT009.Role.holdout \"SAME\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.overwrite_retains_both_split_memberships","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason ∧ ¬(MAT009.finalize s).childReason MAT009.leakageReason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_can_supply_leakage_reason","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (reason : String), s.parent reason → (MAT009.finalize s).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_reason_survives_finalization","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.scan s [] = s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_append","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key ↔\n s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), s.crossed → (MAT009.scan s rows).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_crossed_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.scan s rows)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_familyLeakage_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key ↔ s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_owner_last","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason ↔ s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.Role → String → Prop) → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.splitIntersection","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (members : MAT009.Role → String → Prop),\n MAT009.splitIntersection members = ∃ key, members MAT009.Role.train key ∧ members MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.splitIntersection.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.step","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.step._elambda_1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key ∨ role = row.role ∧ key = row.campaign,\n labs := fun role key => s.labs role key ∨ role = row.role ∧ key = row.lab,\n crossed := s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role,\n parent := s.parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.step.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String × MAT009.Diagnostic.Owner)) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (x : String) (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_15._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_16._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_17._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_18._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_19._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_20._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_21._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_AUDIT declarations=351 theorems=95 diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/declarations.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/declarations.json new file mode 100644 index 0000000..8fd605c --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/declarations.json @@ -0,0 +1,3321 @@ +[ + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Consumer.parent_reason_blocks_any_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "TypedConsumer", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Consumer.shared_campaign_blocks_any_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "TypedConsumer", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = campaign) \u2192\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = campaign) \u2192\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.Owner", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.Registry", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (x : String), MAT009.Diagnostic.empty x = none", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.first_owner_not_last_writer", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 String \u2192 MAT009.Diagnostic.Owner \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 String \u2192 MAT009.Diagnostic.Owner \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : Option MAT009.Diagnostic.Owner \u2192 Sort u_1) \u2192\n (x : Option MAT009.Diagnostic.Owner) \u2192\n (Unit \u2192 motive none) \u2192 ((first : MAT009.Diagnostic.Owner) \u2192 motive (some first)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : Option MAT009.Diagnostic.Owner \u2192 Sort u_1) \u2192\n (x : Option MAT009.Diagnostic.Owner) \u2192\n (Unit \u2192 motive none) \u2192 ((first : MAT009.Diagnostic.Owner) \u2192 motive (some first)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_first_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first \u2192 MAT009.Diagnostic.register registry identity candidate identity = some first", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_new_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none \u2192 MAT009.Diagnostic.register registry identity candidate identity = some candidate", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_other_identity", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key \u2260 identity \u2192 MAT009.Diagnostic.register registry identity candidate key = registry key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_preserves_existing", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.register registry identity candidate key = some first", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n (Unit \u2192 motive []) \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n (Unit \u2192 motive []) \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.scan_first_owner_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (updates : List (String \u00d7 MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.scan registry updates key = some first", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n (t : MAT009.Final) \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.childReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.childReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason \u2227 f.crossed \u2228 reason = MAT009.leakageReason \u2227 f.leakage)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.crossed", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.hasReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.hasReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason \u2228 f.childReason reason)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.leakage", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 Prop \u2192 Prop \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 Prop \u2192 Prop \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } \u2192\n parent = parent_1 \u2227 crossed = crossed_1 \u2227 leakage = leakage_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Final.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 \u2227 crossed = crossed_1 \u2227 leakage = leakage_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.Final} \u2192 v1 = v2 \u2192 MAT009.Final.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.Final \u2192 MAT009.Final \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.parent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n (t : MAT009.Final) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n (t : MAT009.Final) \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final),\n f.status = if \u2203 reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status_blocked_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final), f.status = MAT009.Status.blocked \u2194 \u2203 reason, f.hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status_structural_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated \u2194 \u2200 (reason : String), \u00acf.hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Final.status_structural_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {p : \u03b1 \u2192 Prop}, (\u00ac\u2203 x, p x) = \u2200 (x : \u03b1), \u00acp x", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R1_initial", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none \u2227\n \u00ac(MAT009.initial parent).campaigns role campaign \u2227\n \u00ac(MAT009.initial parent).labs role lab \u2227\n \u00ac(MAT009.initial parent).crossed \u2227 ((MAT009.initial parent).parent reason \u2194 parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R2_assignment_overwrite", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role \u2227\n (\u2200 (key : String), key \u2260 row.campaign \u2192 (MAT009.step s row).owner key = s.owner key) \u2227\n (\u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key \u2194 s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign) \u2227\n \u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key \u2194 s.labs role key \u2228 role = row.role \u2227 key = row.lab", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R3_cross_role_trigger", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed \u2194 s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R4_stickiness", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign \u2192 (MAT009.step s row).campaigns role campaign) \u2227\n (s.labs role lab \u2192 (MAT009.step s row).labs role lab) \u2227\n (s.crossed \u2192 (MAT009.step s row).crossed) \u2227\n (MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)) \u2227\n ((MAT009.step s row).parent reason \u2194 s.parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R5_final_set_intersection", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason \u2194\n (\u2203 key, s.campaigns MAT009.Role.train key \u2227 s.campaigns MAT009.Role.holdout key) \u2228\n \u2203 key, s.labs MAT009.Role.train key \u2227 s.labs MAT009.Role.holdout key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R5_parent_union", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason \u2194 s.parent MAT009.leakageReason \u2228 MAT009.familyLeakage s", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign \u2194\n \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = campaign) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab \u2194 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = lab) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).parent reason \u2194 parent reason)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_cross_trigger_in_finite_scan", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (\u2203 previous, (MAT009.scan s before).owner row.campaign = some previous \u2227 previous \u2260 row.role) \u2192\n (MAT009.scan s (before ++ row :: after)).crossed", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason \u2194\n (\u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = key) \u2228\n \u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.lab = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.lab = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_latest_owner", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R6_parent_reason_survives", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_accepted_example", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_nonvacuous", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(\u2203 rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) \u2227\n \u2203 rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_rejected_example", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.ReasonSet", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 (t : MAT009.Role) \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.holdout", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.holdout.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Role.holdout = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Role} \u2192 x = y \u2192 MAT009.Role.noConfusionType P x y", + "unsafe_definition": false + }, + { + "axioms": [ + "lcUnreachable" + ], + "declaration": "MAT009.Role.noConfusion._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Role} \u2192 x = y \u2192 MAT009.Role.noConfusionType P x y", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 _neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._lambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort v\u271d \u2192 MAT009.Role \u2192 MAT009.Role \u2192 Sort v\u271d", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat_toCtorIdx", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 (t : MAT009.Role) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 (t : MAT009.Role) \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.train", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.train.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Role.train = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.campaign", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n (t : MAT009.Row) \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.lab", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String \u2192 String \u2192 MAT009.Role \u2192 MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String \u2192 String \u2192 MAT009.Role \u2192 MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } \u2192\n campaign = campaign_1 \u2227 lab = lab_1 \u2227 role = role_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Row.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 \u2227 lab = lab_1 \u2227 role = role_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.Row} \u2192 v1 = v2 \u2192 MAT009.Row.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.Row \u2192 MAT009.Row \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n (t : MAT009.Row) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n (t : MAT009.Row) \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.role", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.campaigns", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Role \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n (t : MAT009.State) \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.crossed", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.labs", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Role \u2192 String \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(String \u2192 Option MAT009.Role) \u2192\n (MAT009.Role \u2192 String \u2192 Prop) \u2192 (MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop \u2192 MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk._flat_ctor", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(String \u2192 Option MAT009.Role) \u2192\n (MAT009.Role \u2192 String \u2192 Prop) \u2192 (MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop \u2192 MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk.inj", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {owner : String \u2192 Option MAT009.Role} {campaigns labs : MAT009.Role \u2192 String \u2192 Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String \u2192 Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role \u2192 String \u2192 Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } \u2192\n owner = owner_1 \u2227 campaigns = campaigns_1 \u2227 labs = labs_1 \u2227 crossed = crossed_1 \u2227 parent = parent_1", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.State.mk.injEq", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (owner : String \u2192 Option MAT009.Role) (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String \u2192 Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role \u2192 String \u2192 Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 \u2227 campaigns = campaigns_1 \u2227 labs = labs_1 \u2227 crossed = crossed_1 \u2227 parent = parent_1)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (owner : String \u2192 Option MAT009.Role) (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.State} \u2192 v1 = v2 \u2192 MAT009.State.noConfusionType P v1 v2", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.State \u2192 MAT009.State \u2192 Sort u", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.owner", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.parent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n (t : MAT009.State) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n (t : MAT009.State) \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status._sizeOf_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status._sizeOf_inst", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.blocked", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.blocked.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Status.blocked = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.casesOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n (t : MAT009.Status) \u2192 motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Status} \u2192 x = y \u2192 MAT009.Status.noConfusionType P x y", + "unsafe_definition": false + }, + { + "axioms": [ + "lcUnreachable" + ], + "declaration": "MAT009.Status.noConfusion._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Status} \u2192 x = y \u2192 MAT009.Status.noConfusionType P x y", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 _neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusionType", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort v\u271d \u2192 MAT009.Status \u2192 MAT009.Status \u2192 Sort v\u271d", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat_toCtorIdx", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 (t : MAT009.Status) \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.recOn", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n (t : MAT009.Status) \u2192 motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 motive t", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.structuralOnlyUnauthenticated", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns \u2228 MAT009.splitIntersection s.labs)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage_step_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.finalize", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Final", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.finalize._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Final", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.finalize._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.finalize.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.initial", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._elambda_1", + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.initial._elambda_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.initial._elambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.initial.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [ + "lcProof" + ], + "declaration": "MAT009.instDecidableEqRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._proof_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx \u2192 x = y", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._proof_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Role), \u00acx.toCtorIdx = y.toCtorIdx \u2192 x = y \u2192 False", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [ + "lcProof" + ], + "declaration": "MAT009.instDecidableEqStatus._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 UInt8", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._proof_3", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx \u2192 x = y", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._proof_4", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Status), \u00acx.toCtorIdx = y.toCtorIdx \u2192 x = y \u2192 False", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Row", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Row", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Status", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Status", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String), MAT009.lastRole [] x = none", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : Option MAT009.Role \u2192 Sort u_1) \u2192\n (x : Option MAT009.Role) \u2192 ((role : MAT009.Role) \u2192 motive (some role)) \u2192 (Unit \u2192 motive none) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : Option MAT009.Role \u2192 Sort u_1) \u2192\n (x : Option MAT009.Role) \u2192 ((role : MAT009.Role) \u2192 motive (some role)) \u2192 (Unit \u2192 motive none) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_2", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_2._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.noParent", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.noParent._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.ReasonSet", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.noParent._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.noParent.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String), MAT009.noParent x = False", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.overwrite_retains_both_split_memberships", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout \u2227\n s.campaigns MAT009.Role.train \"SAME\" \u2227 s.campaigns MAT009.Role.holdout \"SAME\"", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.parent_can_supply_leakage_reason", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason \u2227 \u00ac(MAT009.finalize s).childReason MAT009.leakageReason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.parent_reason_survives_finalization", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (reason : String), s.parent reason \u2192 (MAT009.finalize s).hasReason reason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.scan._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.scan._sunfold", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan._unsafe_rec", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State), MAT009.scan s [] = s", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.match_1", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (Unit \u2192 motive []) \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.match_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (Unit \u2192 motive []) \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.scan_append", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key \u2194\n s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {a b : \u03b1}, (a = b) = (b = a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, ((a \u2228 b) \u2228 c) = (a \u2228 b \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, (a \u2228 b \u2228 c) = (b \u2228 a \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_8", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b : Prop}, (a \u2228 b) = (b \u2228 a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_crossed_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row), s.crossed \u2192 (MAT009.scan s rows).crossed", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_familyLeakage_sticky", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.scan s rows)", + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.scan_labs_iff", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key \u2194 s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_5", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {a b : \u03b1}, (a = b) = (b = a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_6", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, ((a \u2228 b) \u2228 c) = (a \u2228 b \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_7", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, (a \u2228 b \u2228 c) = (b \u2228 a \u2228 c)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_8", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b : Prop}, (a \u2228 b) = (b \u2228 a)", + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_owner_last", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan_parent", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason \u2194 s.parent reason", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.splitIntersection", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.splitIntersection.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (members : MAT009.Role \u2192 String \u2192 Prop),\n MAT009.splitIntersection members = \u2203 key, members MAT009.Role.train key \u2227 members MAT009.Role.holdout key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.step", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 MAT009.State", + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 MAT009.State", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._elambda_1", + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.step._elambda_1._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.step._elambda_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.step.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign,\n labs := fun role key => s.labs role key \u2228 role = row.role \u2227 key = row.lab,\n crossed := s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role,\n parent := s.parent }", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) (h_1 : Unit \u2192 motive [])\n (h_2 :\n (identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) (h_1 : Unit \u2192 motive [])\n (h_2 :\n (identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n motive [] \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n motive [] \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 String \u2192 Sort u_1) (x : String) (h_1 : (x : String) \u2192 motive [] x)\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 String \u2192 Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) \u2192 motive [] x)\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : MAT009.Role \u2192 Sort u_1) \u2192\n (x : MAT009.Role) \u2192 (Unit \u2192 motive MAT009.Role.train) \u2192 (Unit \u2192 motive MAT009.Role.holdout) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.match_1.\u00ab_@\u00bb.SplitModel._hyg.109._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : MAT009.Role \u2192 Sort u_1) \u2192\n (x : MAT009.Role) \u2192 (Unit \u2192 motive MAT009.Role.train) \u2192 (Unit \u2192 motive MAT009.Role.holdout) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_13._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_14._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_13._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_14._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_15._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_16._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_17._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_18._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_19._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_20._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_21._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat \u2192 Format", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : MAT009.Status \u2192 Sort u_1) \u2192\n (x : MAT009.Status) \u2192\n (Unit \u2192 motive MAT009.Status.blocked) \u2192 (Unit \u2192 motive MAT009.Status.structuralOnlyUnauthenticated) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.match_1.\u00ab_@\u00bb.SplitModel._hyg.882._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : MAT009.Status \u2192 Sort u_1) \u2192\n (x : MAT009.Status) \u2192\n (Unit \u2192 motive MAT009.Status.blocked) \u2192 (Unit \u2192 motive MAT009.Status.structuralOnlyUnauthenticated) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_1._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_10._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_11._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_12._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_2._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_3._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_4._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_5._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_6._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_7._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_8._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_9._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat \u2192 Format", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.eq_1", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 Sort u_1) (h_1 : Unit \u2192 motive [])\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.eq_2", + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit \u2192 motive [])\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter", + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192 motive [] \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192 motive [] \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_definition": true + } +] diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/lean-version.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/lean-version.json new file mode 100644 index 0000000..10f4b46 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/lean-version.json @@ -0,0 +1,12 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--version" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b", + "timed_out": false, + "timeout_seconds": 30 +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/lean-version.stderr b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/lean-version.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/lean-version.stdout b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/lean-version.stdout new file mode 100644 index 0000000..507e58d --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/lean-version.stdout @@ -0,0 +1 @@ +Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release) diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/named-axioms.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/named-axioms.json new file mode 100644 index 0000000..41676d1 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/named-axioms.json @@ -0,0 +1,62 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Consumer.shared_campaign_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Diagnostic.first_owner_not_last_writer": [ + "propext" + ], + "MAT009.Diagnostic.scan_first_owner_sticky": [ + "propext" + ], + "MAT009.M009_R1_initial": [ + "propext" + ], + "MAT009.M009_R2_assignment_overwrite": [ + "propext" + ], + "MAT009.M009_R3_cross_role_trigger": [], + "MAT009.M009_R4_stickiness": [], + "MAT009.M009_R5_final_set_intersection": [ + "propext" + ], + "MAT009.M009_R5_parent_union": [ + "propext" + ], + "MAT009.M009_R6_arbitrary_finite_scan": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_cross_trigger_in_finite_scan": [ + "propext" + ], + "MAT009.M009_R6_final_leakage_iff": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_latest_owner": [ + "propext" + ], + "MAT009.M009_R6_parent_reason_survives": [], + "MAT009.M009_R7_accepted_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_nonvacuous": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_rejected_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ] +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/result.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/result.json new file mode 100644 index 0000000..cb922b8 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/result.json @@ -0,0 +1,55 @@ +{ + "AUDIT_ACCEPTED": "OPEN", + "DIFFERENTIAL_TESTED": "NOT_EXECUTED", + "MODEL_PROVED": "PASS_FOR_SCOPED_MATHEMATICAL_MODEL", + "REFINEMENT_PROVED": "OPEN", + "baseline_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "compiler_auxiliary_count": 146, + "completed_utc": "2026-11-10T01:00:17.065909+00:00", + "declaration_count": 351, + "external_import_count": 1303, + "input_sha256": { + "DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "LeanAudit.lean": "7aeabffbd65357e4ea41d773950bc7b52c892c5347b259f51d6a3831296aced8", + "PROOF_NOTES.md": "660493388f779bd1fc38a30a8051596e05985250e08b5f51e5c226da7e354cbf", + "SplitModel.lean": "2d6f80e9749e846db5f7c54bcc189c1ae3f345e19677842c002c2bea69790795", + "TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa", + "check.py": "125041442f582e7fc254dc341926b4cfb935ac964057c930021366a950a5a108", + "lean-toolchain": "55e97be96000b5e9e290c9e74482e5e317861499a5540353ce845471bded8cea" + }, + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "lean_version": "Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release)", + "logical_axioms": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "named_intended_theorems": [ + "MAT009.Consumer.parent_reason_blocks_any_scan", + "MAT009.Consumer.shared_campaign_blocks_any_scan", + "MAT009.Diagnostic.first_owner_not_last_writer", + "MAT009.Diagnostic.register_first_owner", + "MAT009.Diagnostic.register_new_owner", + "MAT009.Diagnostic.register_other_identity", + "MAT009.Diagnostic.register_preserves_existing", + "MAT009.Diagnostic.scan_first_owner_sticky", + "MAT009.M009_R1_initial", + "MAT009.M009_R2_assignment_overwrite", + "MAT009.M009_R3_cross_role_trigger", + "MAT009.M009_R4_stickiness", + "MAT009.M009_R5_final_set_intersection", + "MAT009.M009_R5_parent_union", + "MAT009.M009_R6_arbitrary_finite_scan", + "MAT009.M009_R6_cross_trigger_in_finite_scan", + "MAT009.M009_R6_final_leakage_iff", + "MAT009.M009_R6_latest_owner", + "MAT009.M009_R6_parent_reason_survives", + "MAT009.M009_R7_accepted_example", + "MAT009.M009_R7_nonvacuous", + "MAT009.M009_R7_rejected_example" + ], + "started_utc": "2026-11-10T00:59:57.311697+00:00", + "status": "PASS", + "theorem_declaration_count_including_generated": 95 +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/theorem-types.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/theorem-types.json new file mode 100644 index 0000000..1eb358e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/theorem-types.json @@ -0,0 +1,24 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "MAT009.Consumer.shared_campaign_blocks_any_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = campaign) \u2192\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = campaign) \u2192\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "MAT009.Diagnostic.first_owner_not_last_writer": "MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")", + "MAT009.Diagnostic.register_first_owner": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first \u2192 MAT009.Diagnostic.register registry identity candidate identity = some first", + "MAT009.Diagnostic.register_new_owner": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none \u2192 MAT009.Diagnostic.register registry identity candidate identity = some candidate", + "MAT009.Diagnostic.register_other_identity": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key \u2260 identity \u2192 MAT009.Diagnostic.register registry identity candidate key = registry key", + "MAT009.Diagnostic.register_preserves_existing": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.register registry identity candidate key = some first", + "MAT009.Diagnostic.scan_first_owner_sticky": "\u2200 (registry : MAT009.Diagnostic.Registry) (updates : List (String \u00d7 MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.scan registry updates key = some first", + "MAT009.M009_R1_initial": "\u2200 (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none \u2227\n \u00ac(MAT009.initial parent).campaigns role campaign \u2227\n \u00ac(MAT009.initial parent).labs role lab \u2227\n \u00ac(MAT009.initial parent).crossed \u2227 ((MAT009.initial parent).parent reason \u2194 parent reason)", + "MAT009.M009_R2_assignment_overwrite": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role \u2227\n (\u2200 (key : String), key \u2260 row.campaign \u2192 (MAT009.step s row).owner key = s.owner key) \u2227\n (\u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key \u2194 s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign) \u2227\n \u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key \u2194 s.labs role key \u2228 role = row.role \u2227 key = row.lab", + "MAT009.M009_R3_cross_role_trigger": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed \u2194 s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role", + "MAT009.M009_R4_stickiness": "\u2200 (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign \u2192 (MAT009.step s row).campaigns role campaign) \u2227\n (s.labs role lab \u2192 (MAT009.step s row).labs role lab) \u2227\n (s.crossed \u2192 (MAT009.step s row).crossed) \u2227\n (MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)) \u2227\n ((MAT009.step s row).parent reason \u2194 s.parent reason)", + "MAT009.M009_R5_final_set_intersection": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason \u2194\n (\u2203 key, s.campaigns MAT009.Role.train key \u2227 s.campaigns MAT009.Role.holdout key) \u2228\n \u2203 key, s.labs MAT009.Role.train key \u2227 s.labs MAT009.Role.holdout key", + "MAT009.M009_R5_parent_union": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason \u2194 s.parent MAT009.leakageReason \u2228 MAT009.familyLeakage s", + "MAT009.M009_R6_arbitrary_finite_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign \u2194\n \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = campaign) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab \u2194 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = lab) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).parent reason \u2194 parent reason)", + "MAT009.M009_R6_cross_trigger_in_finite_scan": "\u2200 (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (\u2203 previous, (MAT009.scan s before).owner row.campaign = some previous \u2227 previous \u2260 row.role) \u2192\n (MAT009.scan s (before ++ row :: after)).crossed", + "MAT009.M009_R6_final_leakage_iff": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason \u2194\n (\u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = key) \u2228\n \u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.lab = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.lab = key", + "MAT009.M009_R6_latest_owner": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign", + "MAT009.M009_R6_parent_reason_survives": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason", + "MAT009.M009_R7_accepted_example": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated", + "MAT009.M009_R7_nonvacuous": "(\u2203 rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) \u2227\n \u2203 rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked", + "MAT009.M009_R7_rejected_example": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/toolchain-imports.json b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/toolchain-imports.json new file mode 100644 index 0000000..e56b85e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/lean-attempt/toolchain-imports.json @@ -0,0 +1,5214 @@ +{ + "Init": { + "relative_path": "lib/lean/Init.olean", + "sha256": "f14f6c9ea0d9eb2a6fe7bdad84a6610657db3d006805708c1a62ac72b676e944" + }, + "Init.BinderNameHint": { + "relative_path": "lib/lean/Init/BinderNameHint.olean", + "sha256": "87ad3f24763ab6293e9907bd53fd2c87397a1bcc41741d496530391424f397f0" + }, + "Init.BinderPredicates": { + "relative_path": "lib/lean/Init/BinderPredicates.olean", + "sha256": "b87d6204d662e2164c4ccac16ffe6ef34c17e46473219f7615a8e5a902f88399" + }, + "Init.ByCases": { + "relative_path": "lib/lean/Init/ByCases.olean", + "sha256": "a446cd54c7d9b5cd764bac51e0e86bdbfd92cceb559a0ce174c8bfdd0880031f" + }, + "Init.Classical": { + "relative_path": "lib/lean/Init/Classical.olean", + "sha256": "146557a1d2b3d89dccc8a37db0eaf2ca41b7e8b7e9699cc1d2040209ab2d5206" + }, + "Init.Coe": { + "relative_path": "lib/lean/Init/Coe.olean", + "sha256": "8264daae9323339b7a0e4648e9054bc4d6bfa2ed2efe3bbf60f3ed4c85ededf1" + }, + "Init.Control": { + "relative_path": "lib/lean/Init/Control.olean", + "sha256": "02b03cb26d015878cb086d2aa9619d028653c4d7b13f7d27defa18c526f59acf" + }, + "Init.Control.Basic": { + "relative_path": "lib/lean/Init/Control/Basic.olean", + "sha256": "770f96586bd33c585cba7ae023b9ba455fdbcc6656008a7ae44921a2a381e673" + }, + "Init.Control.EState": { + "relative_path": "lib/lean/Init/Control/EState.olean", + "sha256": "bf304f9ebac42bc1e0604ed85fd34ccfbfb1d48c36a0378264daa004c7b1663a" + }, + "Init.Control.Except": { + "relative_path": "lib/lean/Init/Control/Except.olean", + "sha256": "2df44aacfe3c18de279a500ce89ca07fdaae3ac41ee5e13753f675ffcee590bf" + }, + "Init.Control.ExceptCps": { + "relative_path": "lib/lean/Init/Control/ExceptCps.olean", + "sha256": "abf85a131ec12cc4943351cd8e94d25a8ea643d8aed05e3174ddf102a92c82ab" + }, + "Init.Control.Id": { + "relative_path": "lib/lean/Init/Control/Id.olean", + "sha256": "3bdbaf6aab9ebd5bc7f69df7ea3817d60fe3e93621ceac45998aeada2ab0f2fb" + }, + "Init.Control.Lawful": { + "relative_path": "lib/lean/Init/Control/Lawful.olean", + "sha256": "d0e4de63caa049aa63032c262df55cb6e05decd6a639b3197d03a94bfb9cf630" + }, + "Init.Control.Lawful.Basic": { + "relative_path": "lib/lean/Init/Control/Lawful/Basic.olean", + "sha256": "2e5796aeb855144054fe96c87df8c1942fe57363ca46616dd713602e9e83008e" + }, + "Init.Control.Lawful.Instances": { + "relative_path": "lib/lean/Init/Control/Lawful/Instances.olean", + "sha256": "3a42743efc08488094315361697052bbea44791dc9b26bb42a7687be82351798" + }, + "Init.Control.Lawful.Lemmas": { + "relative_path": "lib/lean/Init/Control/Lawful/Lemmas.olean", + "sha256": "872c79b884079a180f2cb4efe5d5ccfd86e8231040ccf0286fdc0ae3e48de6cb" + }, + "Init.Control.Option": { + "relative_path": "lib/lean/Init/Control/Option.olean", + "sha256": "2fd4fd3d76c35d38f22bbd43287b2034db3fc09e9db40a72d64766fc2e1a27cf" + }, + "Init.Control.Reader": { + "relative_path": "lib/lean/Init/Control/Reader.olean", + "sha256": "0ee81ccf6c24215ac02fbddbc47f9d0ec88154c747938db879dc176e84cab35c" + }, + "Init.Control.State": { + "relative_path": "lib/lean/Init/Control/State.olean", + "sha256": "9967249936b6e2882f7c6551ed25b8c11c499e5146884f43c851019a9212b58e" + }, + "Init.Control.StateCps": { + "relative_path": "lib/lean/Init/Control/StateCps.olean", + "sha256": "a7e465f72965884c566492bf128ce366f9b6259feb3ff78a2dc7941276668910" + }, + "Init.Control.StateRef": { + "relative_path": "lib/lean/Init/Control/StateRef.olean", + "sha256": "4c48d97631e2c887a9109f0a3b11930e960674722db2d7ec96228ebb4cebc397" + }, + "Init.Conv": { + "relative_path": "lib/lean/Init/Conv.olean", + "sha256": "27e368664cd48cc7db0b6d8b936fcf3bd3b0c8652d67c7d72ed1a70e481c2cae" + }, + "Init.Core": { + "relative_path": "lib/lean/Init/Core.olean", + "sha256": "325d3e1934d1e99dbf7bde7643d6b1a582e0e98a2bc67156ecbfb1e044c81b62" + }, + "Init.Data": { + "relative_path": "lib/lean/Init/Data.olean", + "sha256": "e0fb356d8ff226c74733d563a2fddfd5d3f9031353f07eab9316189729ea0b05" + }, + "Init.Data.AC": { + "relative_path": "lib/lean/Init/Data/AC.olean", + "sha256": "c31d122ca9a36ebccfade139b5d01a27520cfe5da9c13fbcee0de6afc18e6e2e" + }, + "Init.Data.Array": { + "relative_path": "lib/lean/Init/Data/Array.olean", + "sha256": "628b1fe1e5028d01279c0e4b94f8a75a5404c5c2c62f56cb0f2f93e949b871fe" + }, + "Init.Data.Array.Attach": { + "relative_path": "lib/lean/Init/Data/Array/Attach.olean", + "sha256": "17dd10a433d8c5eefec2380008930b9db90cf5baaf6a111862d248280489809b" + }, + "Init.Data.Array.Basic": { + "relative_path": "lib/lean/Init/Data/Array/Basic.olean", + "sha256": "c1b3ecb3200b55fd9c0f508d6a70518cad1e6cd68e3333d6363ac275efa290b4" + }, + "Init.Data.Array.BasicAux": { + "relative_path": "lib/lean/Init/Data/Array/BasicAux.olean", + "sha256": "498f1b5994a45cd4303c9a5a1252d20f1706d7227fd6068a54a21102c4ecb49d" + }, + "Init.Data.Array.BinSearch": { + "relative_path": "lib/lean/Init/Data/Array/BinSearch.olean", + "sha256": "c8ffd80ccccd8119ba40ef890a3408310abd6535ecb282e8ecd8f8b943dad63a" + }, + "Init.Data.Array.Bootstrap": { + "relative_path": "lib/lean/Init/Data/Array/Bootstrap.olean", + "sha256": "d22a9ec6e5a01f844321cfd7ecfba9f02f0d15cffd6e7667315e36caaf2f4d5d" + }, + "Init.Data.Array.Count": { + "relative_path": "lib/lean/Init/Data/Array/Count.olean", + "sha256": "5cac2d9caf60f31946dcc2b3ecacde3f52d6c143dd91504af2245e9203360700" + }, + "Init.Data.Array.DecidableEq": { + "relative_path": "lib/lean/Init/Data/Array/DecidableEq.olean", + "sha256": "61699c7b47f0fe3ceabab22f86fad529d0c53c229168e2eb5a4c81b3b44161da" + }, + "Init.Data.Array.Erase": { + "relative_path": "lib/lean/Init/Data/Array/Erase.olean", + "sha256": "a39e0a7704569c26626a57596aa4838b835eb5940a90874febcd53aed46c3676" + }, + "Init.Data.Array.Extract": { + "relative_path": "lib/lean/Init/Data/Array/Extract.olean", + "sha256": "d3ae74a38b69aaf4e3f7cf247e3b51d97845035076f21c37f9516f17dec53115" + }, + "Init.Data.Array.FinRange": { + "relative_path": "lib/lean/Init/Data/Array/FinRange.olean", + "sha256": "ccdba2d4e97ed32f04ea6d66ffa24cd4667d3c17e923939d251b12b8c156ff0a" + }, + "Init.Data.Array.Find": { + "relative_path": "lib/lean/Init/Data/Array/Find.olean", + "sha256": "60374792eaf3e1c935911342aadc2e0fe2c2df226d1b2ffeead456d396242565" + }, + "Init.Data.Array.GetLit": { + "relative_path": "lib/lean/Init/Data/Array/GetLit.olean", + "sha256": "7500dfd2f61932caa3bb61dff522cea1d043f9d52f875df9ca9377cb5be6ae00" + }, + "Init.Data.Array.InsertIdx": { + "relative_path": "lib/lean/Init/Data/Array/InsertIdx.olean", + "sha256": "0885128103fece2609d3de7d95170ead99c2422e3b2611efc17ad64d13c54b93" + }, + "Init.Data.Array.InsertionSort": { + "relative_path": "lib/lean/Init/Data/Array/InsertionSort.olean", + "sha256": "00eeffee6c9c944e626b54aa1ba80e2817ee0d6d72a58b4504ed5d6150963199" + }, + "Init.Data.Array.Lemmas": { + "relative_path": "lib/lean/Init/Data/Array/Lemmas.olean", + "sha256": "6d70a718a88e0f5e3a2fbf58ab9a927086ecb80cc131ca4daf61b8373b29bc7e" + }, + "Init.Data.Array.Lex": { + "relative_path": "lib/lean/Init/Data/Array/Lex.olean", + "sha256": "dcfcf549b75b61784fc2761dd6ab27112a5f3f85635156ff45f17907241f873c" + }, + "Init.Data.Array.Lex.Basic": { + "relative_path": "lib/lean/Init/Data/Array/Lex/Basic.olean", + "sha256": "5099ffc811762f879efd0a8d2dc6a6f46b03aaf13e5d7198a40b028f84339f6a" + }, + "Init.Data.Array.Lex.Lemmas": { + "relative_path": "lib/lean/Init/Data/Array/Lex/Lemmas.olean", + "sha256": "edd3b29355f8877ba1d4baa7eb7191d19ec56b68e8caf7136e56562d46f2cf00" + }, + "Init.Data.Array.MapIdx": { + "relative_path": "lib/lean/Init/Data/Array/MapIdx.olean", + "sha256": "fa5fa7562d940a373cde8271701c1b1b6aa4ccc7685a7d8aee563bd6a531b023" + }, + "Init.Data.Array.Mem": { + "relative_path": "lib/lean/Init/Data/Array/Mem.olean", + "sha256": "6d8b81e87c3f6194010d50453930aef26a33d02836f577fdf528f96427fd2871" + }, + "Init.Data.Array.Monadic": { + "relative_path": "lib/lean/Init/Data/Array/Monadic.olean", + "sha256": "4c7ac2031c6b67e8904e378eab4f4e4e52a741464f759346c6bbadf358353040" + }, + "Init.Data.Array.OfFn": { + "relative_path": "lib/lean/Init/Data/Array/OfFn.olean", + "sha256": "269214e9ef1869f764ea7744d27f9bb5f2d88c06a199c35a523bcab485056514" + }, + "Init.Data.Array.Perm": { + "relative_path": "lib/lean/Init/Data/Array/Perm.olean", + "sha256": "df04ccb43fffbdfc14af5e01b9a288eba07cf33dfd934fefc7d3ee62380abbad" + }, + "Init.Data.Array.QSort": { + "relative_path": "lib/lean/Init/Data/Array/QSort.olean", + "sha256": "182e2fb5ccae0e4290f1df223f6da4fe8e4671735b1f8be5768f67aecd976a9b" + }, + "Init.Data.Array.Range": { + "relative_path": "lib/lean/Init/Data/Array/Range.olean", + "sha256": "470d0a04ec3f6acf4e1a4a17c0ac006ff4f4ca6a132e6fe75cb24a3422045edf" + }, + "Init.Data.Array.Set": { + "relative_path": "lib/lean/Init/Data/Array/Set.olean", + "sha256": "47765fffb2b0ff3eeb3b9fcdf1f872a1264fbecc6fd9fa3b3bcacb14305d21cc" + }, + "Init.Data.Array.Subarray": { + "relative_path": "lib/lean/Init/Data/Array/Subarray.olean", + "sha256": "a2b4eb8e9ff8708540ec1224bc150ec997f6b339fc526c8f905824dab5814eb1" + }, + "Init.Data.Array.Subarray.Split": { + "relative_path": "lib/lean/Init/Data/Array/Subarray/Split.olean", + "sha256": "e70f52b7a240f6f48ece84e6e5efe81be6f0aa59787d93877069acf4d299d6da" + }, + "Init.Data.Array.TakeDrop": { + "relative_path": "lib/lean/Init/Data/Array/TakeDrop.olean", + "sha256": "cb756a88720cd6633a931cc4cd278804391f1d4b6e7804fed40e0014f27250e4" + }, + "Init.Data.Array.Zip": { + "relative_path": "lib/lean/Init/Data/Array/Zip.olean", + "sha256": "57b72c19de8fc1a600d24da0a2ce3edc78620fc487668928f5092c62e6199bf8" + }, + "Init.Data.BEq": { + "relative_path": "lib/lean/Init/Data/BEq.olean", + "sha256": "fc264bbc09afcdee4cf301170287f97dce8426a1102c2c20a2b3324af470be03" + }, + "Init.Data.Basic": { + "relative_path": "lib/lean/Init/Data/Basic.olean", + "sha256": "320b6a318c7f47b88b4cc52a3dd10f1c253c4ba15882c0fba4d0b6cc8b258629" + }, + "Init.Data.BitVec": { + "relative_path": "lib/lean/Init/Data/BitVec.olean", + "sha256": "9806987569400445640812d3675deb3d56b79c12d42e8168aebba2d2d42ef3cd" + }, + "Init.Data.BitVec.Basic": { + "relative_path": "lib/lean/Init/Data/BitVec/Basic.olean", + "sha256": "263c59d8eecd1dca7acf46649c80ce9d7b5680064309b9eedc76d4ca02a03e34" + }, + "Init.Data.BitVec.BasicAux": { + "relative_path": "lib/lean/Init/Data/BitVec/BasicAux.olean", + "sha256": "1ba7804f2a9d1739a51b1e7dea3821a38743373b1072bf85c41d247cfa8bcbaa" + }, + "Init.Data.BitVec.Bitblast": { + "relative_path": "lib/lean/Init/Data/BitVec/Bitblast.olean", + "sha256": "c7663248b6910786438135f4eabd9f5fce7ddb61628c667345d04c4be6dda7b3" + }, + "Init.Data.BitVec.Folds": { + "relative_path": "lib/lean/Init/Data/BitVec/Folds.olean", + "sha256": "b4d4aa0cfd3f346fd1f6361552afcf5245668c55fd2d0ad1ebf467f841ae20d0" + }, + "Init.Data.BitVec.Lemmas": { + "relative_path": "lib/lean/Init/Data/BitVec/Lemmas.olean", + "sha256": "c11aebc16adf6f6fdd8d3a9dcb74b295034999579793c2f4eb79b044fccd618e" + }, + "Init.Data.Bool": { + "relative_path": "lib/lean/Init/Data/Bool.olean", + "sha256": "24c3fa2ac49e5f1681100130790a5f322bed745e47b503e25ff49b7a3c5f6d68" + }, + "Init.Data.ByteArray": { + "relative_path": "lib/lean/Init/Data/ByteArray.olean", + "sha256": "3c0fa93b6b78ea8b3733b02a83dca06a085b3938355811eee6c06cbdd0179a8e" + }, + "Init.Data.ByteArray.Basic": { + "relative_path": "lib/lean/Init/Data/ByteArray/Basic.olean", + "sha256": "f995de7efe27dc6573bf9cf32e2399ba4ee0659f0b64f07285bb15edbd8048fd" + }, + "Init.Data.Cast": { + "relative_path": "lib/lean/Init/Data/Cast.olean", + "sha256": "3413b2ca8a0098a6e572d7728ed1532eaa21ca10067197f3b214aeff2ccdd651" + }, + "Init.Data.Channel": { + "relative_path": "lib/lean/Init/Data/Channel.olean", + "sha256": "945114f1dd771f97d93cdac7466ff0ff1e0f1461bc4fda27b5f5b9715dcdc174" + }, + "Init.Data.Char": { + "relative_path": "lib/lean/Init/Data/Char.olean", + "sha256": "818aac23581c282c3f6d2f80775ac47ce6d31b55ce54b3d187b6ed4b8de8cc63" + }, + "Init.Data.Char.Basic": { + "relative_path": "lib/lean/Init/Data/Char/Basic.olean", + "sha256": "6ed0988e9f8e134dbc30d38ed257a44850e98d71b7d77d5a977f4297e085a0f1" + }, + "Init.Data.Char.Lemmas": { + "relative_path": "lib/lean/Init/Data/Char/Lemmas.olean", + "sha256": "030a6cdcb16360b9f90d072e40bd66ce8aafab43137dd9d03e82229ebec3ced9" + }, + "Init.Data.Fin": { + "relative_path": "lib/lean/Init/Data/Fin.olean", + "sha256": "e955ad0ee4c253aaf23086b1452740c2c9888c594b9c404bb34699868773dfe2" + }, + "Init.Data.Fin.Basic": { + "relative_path": "lib/lean/Init/Data/Fin/Basic.olean", + "sha256": "e4b2abb6d8a424da6e7ff21b0e71ead051c0605e76db3680888305ac128f5b55" + }, + "Init.Data.Fin.Bitwise": { + "relative_path": "lib/lean/Init/Data/Fin/Bitwise.olean", + "sha256": "e80029b17e55e5e4b917ef076545aa017bb7844bed24f7f3c376952d82f3e21b" + }, + "Init.Data.Fin.Fold": { + "relative_path": "lib/lean/Init/Data/Fin/Fold.olean", + "sha256": "8d618def1ed982a59898c72e714939d861836ea9f84fe4414677c4b7fac9295a" + }, + "Init.Data.Fin.Iterate": { + "relative_path": "lib/lean/Init/Data/Fin/Iterate.olean", + "sha256": "f6553fbf009244d2b848079f104ef424f9048ad5e5e45276169f58b674dbdf58" + }, + "Init.Data.Fin.Lemmas": { + "relative_path": "lib/lean/Init/Data/Fin/Lemmas.olean", + "sha256": "9fe597ce2f3edce6a67a4542d72bd0300cc643a484297fc8d61966a28b61935d" + }, + "Init.Data.Fin.Log2": { + "relative_path": "lib/lean/Init/Data/Fin/Log2.olean", + "sha256": "d4e9f3e05222a066c5fdc327065d7147d16a939ebcedf988b8e428bfd7a1d6a3" + }, + "Init.Data.Float": { + "relative_path": "lib/lean/Init/Data/Float.olean", + "sha256": "92478058b9b83eddef7ecea3797414d74db6e61e2b688e64ab7ba81df127b15a" + }, + "Init.Data.Float32": { + "relative_path": "lib/lean/Init/Data/Float32.olean", + "sha256": "2a37e1add33b9d6047350feaa9d87b913f1e58718bd5a3cb597d60e6573f9212" + }, + "Init.Data.FloatArray": { + "relative_path": "lib/lean/Init/Data/FloatArray.olean", + "sha256": "78c9b7500ea433aede3b8587af3bbbe727c8ebfd6f8a5942f6c0d14b0faa44b5" + }, + "Init.Data.FloatArray.Basic": { + "relative_path": "lib/lean/Init/Data/FloatArray/Basic.olean", + "sha256": "7169a26af51b7faaa9712ed85d9423a43b5c4f31ba4ccdbb3289eeaaf58e0afa" + }, + "Init.Data.Format": { + "relative_path": "lib/lean/Init/Data/Format.olean", + "sha256": "82528100ce60ae1eded58f45a0319b76ac7c80f9d834c60bec31cddd2a1f836b" + }, + "Init.Data.Format.Basic": { + "relative_path": "lib/lean/Init/Data/Format/Basic.olean", + "sha256": "7b7e7500d7a86ce98f996e4c6045c7fff49ee0efc72737cfc5ab4c284ad77f4a" + }, + "Init.Data.Format.Instances": { + "relative_path": "lib/lean/Init/Data/Format/Instances.olean", + "sha256": "b8bede2673426df8591cc8d2837854e12fd82f83132adcdb5d4fa6492b9f1d21" + }, + "Init.Data.Format.Macro": { + "relative_path": "lib/lean/Init/Data/Format/Macro.olean", + "sha256": "d4b42a5cd357e4c35a328183571bb8a919d2dba0e0241b081293c449b726ae35" + }, + "Init.Data.Format.Syntax": { + "relative_path": "lib/lean/Init/Data/Format/Syntax.olean", + "sha256": "3433640ca9aeb5ef96fda95bf9dc747d0feba236f3a3db2860f92970c5718882" + }, + "Init.Data.Function": { + "relative_path": "lib/lean/Init/Data/Function.olean", + "sha256": "17fa8cf9a33f44e97d1a3a8c77e086c567ef0520291421839b77b28fdbd2b8fa" + }, + "Init.Data.Hashable": { + "relative_path": "lib/lean/Init/Data/Hashable.olean", + "sha256": "0d9ba8712572cf7103ef0e4c1012f4c3d1b10bbc3f9d55409eb315ed87f26e7f" + }, + "Init.Data.Int": { + "relative_path": "lib/lean/Init/Data/Int.olean", + "sha256": "4628002a234694983f14e288745898d889aada1b0d9d9fbff5f3fb8dbb72c20a" + }, + "Init.Data.Int.Basic": { + "relative_path": "lib/lean/Init/Data/Int/Basic.olean", + "sha256": "926f11cf3beb5d66e06dc405f6aac7f39b38c440ba23baa26827ca79724b8eae" + }, + "Init.Data.Int.Bitwise": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise.olean", + "sha256": "527f601e3b6565c4e13a78e71c252c99f51b0203fba8e9a48bf61a6d702f7f77" + }, + "Init.Data.Int.Bitwise.Basic": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise/Basic.olean", + "sha256": "265104afaeebfc4163d1f1ab6bc8913ec7def48a6e0cf7c33a619e7c6b7996cd" + }, + "Init.Data.Int.Bitwise.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise/Lemmas.olean", + "sha256": "61fdbf3f93888946c2c76b36a1ac73246abd87048eb30a596d009a0dddfe3af0" + }, + "Init.Data.Int.Cooper": { + "relative_path": "lib/lean/Init/Data/Int/Cooper.olean", + "sha256": "607b77466cb24c6ae2b99b1bd054709dd7e315d0019d87854e45e588d2f4f061" + }, + "Init.Data.Int.DivMod": { + "relative_path": "lib/lean/Init/Data/Int/DivMod.olean", + "sha256": "0ac18881bb522630e818a1f973051dd26d51a7edfe6589132274694575627416" + }, + "Init.Data.Int.DivMod.Basic": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Basic.olean", + "sha256": "1bf5aad5de1a3d6931194060a4fe8fa304dced06404dd2815057179beecb7945" + }, + "Init.Data.Int.DivMod.Bootstrap": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Bootstrap.olean", + "sha256": "9f5e940c4fba88142e73ea864aee5257a1bf31566d3d67d1ebdd60967230d2c5" + }, + "Init.Data.Int.DivMod.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Lemmas.olean", + "sha256": "dbb9ae219e1f2072be3ed6986c5f713b1df79f563fab946fc903c7bcfdce7f48" + }, + "Init.Data.Int.Gcd": { + "relative_path": "lib/lean/Init/Data/Int/Gcd.olean", + "sha256": "294b7f9b1144098337d3b1eae9a286741c2a503388078bd601cf03bbc74e5af8" + }, + "Init.Data.Int.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/Lemmas.olean", + "sha256": "e447675a36f3fa775915d9c711e4172eb1575cb80d4f631ea9b4a0cf7319d791" + }, + "Init.Data.Int.LemmasAux": { + "relative_path": "lib/lean/Init/Data/Int/LemmasAux.olean", + "sha256": "f58eaab4a411b1dd8b2505d7b5479dc203c603ea9ee4a28dfc2e37ac6a1c50d3" + }, + "Init.Data.Int.Linear": { + "relative_path": "lib/lean/Init/Data/Int/Linear.olean", + "sha256": "a6f99acdf60bcb9b582ef87f01c9d53a76e61ea6466a7f4a9d5e4d5c9f564bc8" + }, + "Init.Data.Int.OfNat": { + "relative_path": "lib/lean/Init/Data/Int/OfNat.olean", + "sha256": "8b91634fcd25ef8639461730e11a2e30d7c0f479bd7c86064f1dbb0edf05d47c" + }, + "Init.Data.Int.Order": { + "relative_path": "lib/lean/Init/Data/Int/Order.olean", + "sha256": "32e716ca6845ff6b54befdb1d6fa157e6980471455c22c7c34a5fa1b206c5aaf" + }, + "Init.Data.Int.Pow": { + "relative_path": "lib/lean/Init/Data/Int/Pow.olean", + "sha256": "916584050412a63f5e067a8d86818a2576cd971f241d2bcce80da6ad9d2cebcd" + }, + "Init.Data.List": { + "relative_path": "lib/lean/Init/Data/List.olean", + "sha256": "a0b4ba4434de3cbe61e2009557a6b2c237e7ed24d903486b02efc2460594ebbe" + }, + "Init.Data.List.Attach": { + "relative_path": "lib/lean/Init/Data/List/Attach.olean", + "sha256": "1b460daad56a1203c465d63575d1fd1b0c417c9b22daa53d1239d3e3cf8858e3" + }, + "Init.Data.List.Basic": { + "relative_path": "lib/lean/Init/Data/List/Basic.olean", + "sha256": "45f40cdc05ba064b67aff84c6957f82c4a2e6edd0052fa508cc749e9d35999e1" + }, + "Init.Data.List.BasicAux": { + "relative_path": "lib/lean/Init/Data/List/BasicAux.olean", + "sha256": "210a850a3c6f96fb462b42a67920eed86b41cdfafd32adb39a272d4f66ab09fe" + }, + "Init.Data.List.Control": { + "relative_path": "lib/lean/Init/Data/List/Control.olean", + "sha256": "b082dae0a9caf27e9ebecc9d183598e091016f323b6b1c30942bfe9ac14915b6" + }, + "Init.Data.List.Count": { + "relative_path": "lib/lean/Init/Data/List/Count.olean", + "sha256": "37e1a1a86c77f09c1ae6f13af53e9f0fbc8dd888485e1796b1c0b2813904811a" + }, + "Init.Data.List.Erase": { + "relative_path": "lib/lean/Init/Data/List/Erase.olean", + "sha256": "2ff3cc2f53a947bba4110106d48bd8e6a746fbdbccda3d3168988377f9bf08d6" + }, + "Init.Data.List.FinRange": { + "relative_path": "lib/lean/Init/Data/List/FinRange.olean", + "sha256": "174b84f766bfad55861d5f9bf45051d705e4762491232c25589eda8491aee1fb" + }, + "Init.Data.List.Find": { + "relative_path": "lib/lean/Init/Data/List/Find.olean", + "sha256": "10dabc67b4e589018d889930fc75a663a75d91c7f083095e5892c3e359019d1d" + }, + "Init.Data.List.Impl": { + "relative_path": "lib/lean/Init/Data/List/Impl.olean", + "sha256": "1e62f8c4f057317bb61e73e76f39cbd3b699c7a45c168ab405f7c2cf35c3d2fe" + }, + "Init.Data.List.Lemmas": { + "relative_path": "lib/lean/Init/Data/List/Lemmas.olean", + "sha256": "ebcbcfb4dfc92e4eb9ece72b6c538b4809f96585313aef48cc91ed3e386f2ecc" + }, + "Init.Data.List.Lex": { + "relative_path": "lib/lean/Init/Data/List/Lex.olean", + "sha256": "3b9fb1bdab57ade29c2834da21d90ae802ccf7e58899b17ff487f6483c56ec72" + }, + "Init.Data.List.MapIdx": { + "relative_path": "lib/lean/Init/Data/List/MapIdx.olean", + "sha256": "bd024799a195c348a5937950048fddade6c7cc32ca43abc8e93a0d77c9593f3c" + }, + "Init.Data.List.MinMax": { + "relative_path": "lib/lean/Init/Data/List/MinMax.olean", + "sha256": "1fc6795971ac8f3530113326fb3e351626a4146db9c4772152b2ffe4a3bb81e1" + }, + "Init.Data.List.Monadic": { + "relative_path": "lib/lean/Init/Data/List/Monadic.olean", + "sha256": "82900949d78e7fc5b7c6415194cba03b2526409b350a39f923a78d9911132448" + }, + "Init.Data.List.Nat": { + "relative_path": "lib/lean/Init/Data/List/Nat.olean", + "sha256": "7963464ebb33af6223be0712ffb5bbe47c4587ae5380a61cbc5c6021baf9b422" + }, + "Init.Data.List.Nat.BEq": { + "relative_path": "lib/lean/Init/Data/List/Nat/BEq.olean", + "sha256": "fa52c59704dd8e1822d4b0257d670aedbb2f82017b74303bf358af42d494a450" + }, + "Init.Data.List.Nat.Basic": { + "relative_path": "lib/lean/Init/Data/List/Nat/Basic.olean", + "sha256": "745ae4e831f8597a5165d4dc9abc953c280a450a6547963f109c0fc18cbd6746" + }, + "Init.Data.List.Nat.Count": { + "relative_path": "lib/lean/Init/Data/List/Nat/Count.olean", + "sha256": "73ccebc5a9a303a8a9f2c9137d3fb60c3191b4d74c40370e53dc15e781536493" + }, + "Init.Data.List.Nat.Erase": { + "relative_path": "lib/lean/Init/Data/List/Nat/Erase.olean", + "sha256": "b8d0f4703d71d05efc7c94d8d2c2bad1278f1c65302ce0ee11275e93857f3b3c" + }, + "Init.Data.List.Nat.Find": { + "relative_path": "lib/lean/Init/Data/List/Nat/Find.olean", + "sha256": "73d6e91b894c9907bdb3a7087fa1fcc174fe4a96aac39055a797b84b8ec5f26a" + }, + "Init.Data.List.Nat.InsertIdx": { + "relative_path": "lib/lean/Init/Data/List/Nat/InsertIdx.olean", + "sha256": "5c5ac7ada578ca3a04908c1c6b94e2f12e684da28a3534fd8e2fb1712ba06a38" + }, + "Init.Data.List.Nat.Modify": { + "relative_path": "lib/lean/Init/Data/List/Nat/Modify.olean", + "sha256": "275e5291a6691082786680f93b2e0d09710e0fbcd9640b6503bbbf35041756aa" + }, + "Init.Data.List.Nat.Pairwise": { + "relative_path": "lib/lean/Init/Data/List/Nat/Pairwise.olean", + "sha256": "8aae1be95bb7c08d8e20bde2bdc46d737a4c54c6c132fb093782603e11f88e36" + }, + "Init.Data.List.Nat.Perm": { + "relative_path": "lib/lean/Init/Data/List/Nat/Perm.olean", + "sha256": "d34b546b7057199bf2b89b45908696cdc173bcbb8ff6e14c20e8553fce164014" + }, + "Init.Data.List.Nat.Range": { + "relative_path": "lib/lean/Init/Data/List/Nat/Range.olean", + "sha256": "56804bb0f398b27aba960edeff1d44703f3d59c67c72f540b9e4016fe7e005a3" + }, + "Init.Data.List.Nat.Sublist": { + "relative_path": "lib/lean/Init/Data/List/Nat/Sublist.olean", + "sha256": "cb179f24812905731bee16e0aabbf5eda0d6e1a07d693a0297798e3fab4316ab" + }, + "Init.Data.List.Nat.TakeDrop": { + "relative_path": "lib/lean/Init/Data/List/Nat/TakeDrop.olean", + "sha256": "86594d76cd6bca152ceabb5eaf14e7d2843b484cc2ae20233bf70eca4db3d470" + }, + "Init.Data.List.Notation": { + "relative_path": "lib/lean/Init/Data/List/Notation.olean", + "sha256": "231f63a53a24060f593b32f6321d2e5f1159bdb57172f5fd3e9ca2c38f137733" + }, + "Init.Data.List.OfFn": { + "relative_path": "lib/lean/Init/Data/List/OfFn.olean", + "sha256": "4d4a1feaf8df21b7567908a2723e0cd0bbb9ab1568a9cf1e6536c08a177c1119" + }, + "Init.Data.List.Pairwise": { + "relative_path": "lib/lean/Init/Data/List/Pairwise.olean", + "sha256": "6a00f9b67bb5554815fb9ca404ddf0f7df1fcb0c53d9b40a7de569f752a70779" + }, + "Init.Data.List.Perm": { + "relative_path": "lib/lean/Init/Data/List/Perm.olean", + "sha256": "16c720de1fc7adedfc438ed72845cdc53267779413765172a77e4540662d1a10" + }, + "Init.Data.List.Range": { + "relative_path": "lib/lean/Init/Data/List/Range.olean", + "sha256": "646ca36cfb7cb2359c5589af542f7b1714018cd2c2e06e705f38e8e69515ef29" + }, + "Init.Data.List.Sort": { + "relative_path": "lib/lean/Init/Data/List/Sort.olean", + "sha256": "c2718b7978559839c5c4493fa3a8efec0f89b75ba052319781ff102e2d4f874a" + }, + "Init.Data.List.Sort.Basic": { + "relative_path": "lib/lean/Init/Data/List/Sort/Basic.olean", + "sha256": "2358d6d69b08c0a229dd3fdc38598e300f65e534ac1a3db61495d2c68440b783" + }, + "Init.Data.List.Sort.Impl": { + "relative_path": "lib/lean/Init/Data/List/Sort/Impl.olean", + "sha256": "663f7c421f200455d1b5f73bbb1bc7698a83258cc2b8dd36d537f016f9eb9a77" + }, + "Init.Data.List.Sort.Lemmas": { + "relative_path": "lib/lean/Init/Data/List/Sort/Lemmas.olean", + "sha256": "8c31e71b3777de0363ff903a15fb77da2b64ca6e2a6df7e0f169c6fa6c68b9fc" + }, + "Init.Data.List.Sublist": { + "relative_path": "lib/lean/Init/Data/List/Sublist.olean", + "sha256": "626fc37b3fccd3ad01e524e497bed2e7470f69025ffb5c96477c5dda33cf93b8" + }, + "Init.Data.List.TakeDrop": { + "relative_path": "lib/lean/Init/Data/List/TakeDrop.olean", + "sha256": "6ad55d35f8158e3093612d2bd82b2fcc6e0e2692b89276374fbad91d05316236" + }, + "Init.Data.List.ToArray": { + "relative_path": "lib/lean/Init/Data/List/ToArray.olean", + "sha256": "d48db070507418071d7f3294285e8fd02ded1fe084445b6a728476fa0e5ef34b" + }, + "Init.Data.List.ToArrayImpl": { + "relative_path": "lib/lean/Init/Data/List/ToArrayImpl.olean", + "sha256": "877b70f91eb55124127734da7195914515b98abc3d601053119e4d10b3c749bf" + }, + "Init.Data.List.Zip": { + "relative_path": "lib/lean/Init/Data/List/Zip.olean", + "sha256": "b3ec8eed3d680c246fefdb0e57293acd2c2257a085937f2d1e026d118f6d3979" + }, + "Init.Data.Nat": { + "relative_path": "lib/lean/Init/Data/Nat.olean", + "sha256": "3447a7734bddbbc6904f5135e848dbca25c10bc5b6fad83b1beb09ac5bdb1fae" + }, + "Init.Data.Nat.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Basic.olean", + "sha256": "b2d11a9c4afa558c793fa12d41da087604ee0cf5dd8ee4f3c2f0b08e90031a50" + }, + "Init.Data.Nat.Bitwise": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise.olean", + "sha256": "ec84e12fb7c621de1fe2a6d0cf393bdec0b211e0741b6b343130d09417e0adc9" + }, + "Init.Data.Nat.Bitwise.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise/Basic.olean", + "sha256": "8f01e5e6af6b3366171fb8f21ba8a336c0ddef11a2a180b0fc033ef53757a69a" + }, + "Init.Data.Nat.Bitwise.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise/Lemmas.olean", + "sha256": "844179c496ff2ff5233abfec08e333e04170dd8b49a43f98ae15be7539b83b4b" + }, + "Init.Data.Nat.Compare": { + "relative_path": "lib/lean/Init/Data/Nat/Compare.olean", + "sha256": "9ce920efa06d6fb5e143925d07dd673e488640a5fc56c8c814ef41f383a0b6aa" + }, + "Init.Data.Nat.Control": { + "relative_path": "lib/lean/Init/Data/Nat/Control.olean", + "sha256": "126864791c444a3025fb8be008a42e792773f82535cb1fe9c80b6a9b0cbb0783" + }, + "Init.Data.Nat.Div.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Div/Basic.olean", + "sha256": "90ace86481881951b8aac0c78b829052894c5168bb81b4e32c48daefe634259e" + }, + "Init.Data.Nat.Div.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Div/Lemmas.olean", + "sha256": "06a8a626caa61480fa596adfa0fe6230b4b84cdbbf4f049da8a744dffa25efbc" + }, + "Init.Data.Nat.Dvd": { + "relative_path": "lib/lean/Init/Data/Nat/Dvd.olean", + "sha256": "36f58914fb3acef3f1b99aae4e1024647886c96f3575cd2cdb7b90e48b63a62f" + }, + "Init.Data.Nat.Fold": { + "relative_path": "lib/lean/Init/Data/Nat/Fold.olean", + "sha256": "ccbbc29df5d8b98e47f6d1ee36aa3cb036aa61c3adad7945bd72ef22117ecf0a" + }, + "Init.Data.Nat.Gcd": { + "relative_path": "lib/lean/Init/Data/Nat/Gcd.olean", + "sha256": "746fe45b4e8c648caebc10c1ba9e2736ebd492bb4854edc96c8d5c0f10905666" + }, + "Init.Data.Nat.Lcm": { + "relative_path": "lib/lean/Init/Data/Nat/Lcm.olean", + "sha256": "bbb02321b1e2b2422adf0d8c10b3800afe668a9edbb434e3dbd83c45386539de" + }, + "Init.Data.Nat.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Lemmas.olean", + "sha256": "7acb7e4f1b14d45188f28aa341f9013ee1c6bba8f0e1c2f3be74e04dd24b4782" + }, + "Init.Data.Nat.Linear": { + "relative_path": "lib/lean/Init/Data/Nat/Linear.olean", + "sha256": "33b034e32879e503ae843a62df9969d47e341eddf2650e299209e1494e507c2c" + }, + "Init.Data.Nat.Log2": { + "relative_path": "lib/lean/Init/Data/Nat/Log2.olean", + "sha256": "a1147619414a0561c2e404ca16b6f9c1b3e764fd66917d26964ff53d6f33d10b" + }, + "Init.Data.Nat.MinMax": { + "relative_path": "lib/lean/Init/Data/Nat/MinMax.olean", + "sha256": "813cd65d09f92a707754d8d86d35ae396b2ac77953076e7444021250799546dc" + }, + "Init.Data.Nat.Mod": { + "relative_path": "lib/lean/Init/Data/Nat/Mod.olean", + "sha256": "232fa20934aab58dfc025430ba91fe814d90e0e67f979a401fc91ea8a0fd06e3" + }, + "Init.Data.Nat.Power2": { + "relative_path": "lib/lean/Init/Data/Nat/Power2.olean", + "sha256": "aa68d47f1481ea940e4f2f3eeb5eb0cf44d9d36a81f02609f834bce92b36144a" + }, + "Init.Data.Nat.SOM": { + "relative_path": "lib/lean/Init/Data/Nat/SOM.olean", + "sha256": "be398ccbd96728c1500ab66aa2063131d37d6acd214067dbe14fb3a61150ff4d" + }, + "Init.Data.Nat.Simproc": { + "relative_path": "lib/lean/Init/Data/Nat/Simproc.olean", + "sha256": "491fdb35ea98fc6d352b6cb46c3681d42cb9e23f2df42a07a8e764b54ef7a62b" + }, + "Init.Data.NeZero": { + "relative_path": "lib/lean/Init/Data/NeZero.olean", + "sha256": "5fcec208f2769e4ec00ebf7dc0b534ffba76859d7390bac0ba36da69c8d06d0d" + }, + "Init.Data.OfScientific": { + "relative_path": "lib/lean/Init/Data/OfScientific.olean", + "sha256": "5a86fb094fc122609b959999bc53159282db03b2aba36b1d564270c95b630cc7" + }, + "Init.Data.Option": { + "relative_path": "lib/lean/Init/Data/Option.olean", + "sha256": "7cec7ba7cbb4f8c12b723822ef37fa80d7fe6dad55ffe781b04d480f37bee3e9" + }, + "Init.Data.Option.Attach": { + "relative_path": "lib/lean/Init/Data/Option/Attach.olean", + "sha256": "d13d8661e92455466e2652e81b0fc20660c6f68f61563e06ff9ada3b2adef85e" + }, + "Init.Data.Option.Basic": { + "relative_path": "lib/lean/Init/Data/Option/Basic.olean", + "sha256": "8a83ae7602811f2a8caa2f5ec890dfcaad71b7fee193f45329f23ce538838eae" + }, + "Init.Data.Option.BasicAux": { + "relative_path": "lib/lean/Init/Data/Option/BasicAux.olean", + "sha256": "69c9769a227956d0a18263f65759b2c78eeca5fc23df52fada29fae941be58b8" + }, + "Init.Data.Option.Instances": { + "relative_path": "lib/lean/Init/Data/Option/Instances.olean", + "sha256": "c2af58842fc1a5ace3156d8cc201a287eb79ad7707be50f11d43d9f6096452b8" + }, + "Init.Data.Option.Lemmas": { + "relative_path": "lib/lean/Init/Data/Option/Lemmas.olean", + "sha256": "832a8d1633685e7ace5ceb52ee44b1f441548ff85b6f15687314cc3709b9138e" + }, + "Init.Data.Option.List": { + "relative_path": "lib/lean/Init/Data/Option/List.olean", + "sha256": "919cbd303c6345f52d6c019146d46b4249daf12fe9fd3c2cfbece14797be8393" + }, + "Init.Data.Option.Monadic": { + "relative_path": "lib/lean/Init/Data/Option/Monadic.olean", + "sha256": "6f76327d567c5dbf041689c11ff396fdebbc832a1640d003ad2020671282aeb1" + }, + "Init.Data.Ord": { + "relative_path": "lib/lean/Init/Data/Ord.olean", + "sha256": "f9c47b462803dd4e251e3c89acc944998c255728461d0b038aa239e067c81a9c" + }, + "Init.Data.PLift": { + "relative_path": "lib/lean/Init/Data/PLift.olean", + "sha256": "2bed69175449aa3166dc103d9cf368e494b4d1752ed6e864250214256d710739" + }, + "Init.Data.Prod": { + "relative_path": "lib/lean/Init/Data/Prod.olean", + "sha256": "0498bf822d3922cd5bbc154bf0adef4fd76e4fe6a57f8e39fefa49ae9e16ca13" + }, + "Init.Data.Queue": { + "relative_path": "lib/lean/Init/Data/Queue.olean", + "sha256": "ab5118c07c9c0ed7d0819d19d442d1e6143f265f784f48151be1c4e2cd895606" + }, + "Init.Data.RArray": { + "relative_path": "lib/lean/Init/Data/RArray.olean", + "sha256": "9abe7370b3817a85b8512bc51dadc386f314bdcec188736b2f87405d5a9bb09b" + }, + "Init.Data.Random": { + "relative_path": "lib/lean/Init/Data/Random.olean", + "sha256": "5a34ed96d6a9814781db7e6c93847b8cd7caeb7071b2256058964866ec706af5" + }, + "Init.Data.Range": { + "relative_path": "lib/lean/Init/Data/Range.olean", + "sha256": "c64640dc9f5f61844778a90d7acc0f8f632ec11aa1746689c960d0f459bfaf46" + }, + "Init.Data.Range.Basic": { + "relative_path": "lib/lean/Init/Data/Range/Basic.olean", + "sha256": "bf692fd52dbffb6518f9a189179263fc4c49b436dbdb9eba2f00940de6665353" + }, + "Init.Data.Range.Lemmas": { + "relative_path": "lib/lean/Init/Data/Range/Lemmas.olean", + "sha256": "19e241eb048d7046e42e9117499d5bc8a43dddf66dacbb087966b4d16b82b06b" + }, + "Init.Data.Repr": { + "relative_path": "lib/lean/Init/Data/Repr.olean", + "sha256": "cbbd2014d6cee442d42c9c4d6997aa1e27dd3a4ea4fef43d1de4c1f184d02138" + }, + "Init.Data.SInt": { + "relative_path": "lib/lean/Init/Data/SInt.olean", + "sha256": "21f02e1e015c8ceee0e8afe9a24f8150714739a4df724b922e7b3f3756cc530d" + }, + "Init.Data.SInt.Basic": { + "relative_path": "lib/lean/Init/Data/SInt/Basic.olean", + "sha256": "c4b9b22f462ffe3dac0f5ce0d810e9cbbd3dda83a3c8f61aaca350f99edf30d9" + }, + "Init.Data.SInt.Bitwise": { + "relative_path": "lib/lean/Init/Data/SInt/Bitwise.olean", + "sha256": "784166152e7e37d32e49f556007eb9e8ac78a11e25a33159256124b1b6ac78b9" + }, + "Init.Data.SInt.Float": { + "relative_path": "lib/lean/Init/Data/SInt/Float.olean", + "sha256": "0fa2df58fc374f7d8f8381dc7369e0359fd56854418863015d82b50a49032bdd" + }, + "Init.Data.SInt.Float32": { + "relative_path": "lib/lean/Init/Data/SInt/Float32.olean", + "sha256": "08b0e06d73a8cc4989ef19e5b5dc0255aa458e852dade1660aeee88046199fb6" + }, + "Init.Data.SInt.Lemmas": { + "relative_path": "lib/lean/Init/Data/SInt/Lemmas.olean", + "sha256": "14f5714b32a97f7b89fe4f737e96d2d9576a75fdbdf62b848c26140b1be0d0b9" + }, + "Init.Data.Stream": { + "relative_path": "lib/lean/Init/Data/Stream.olean", + "sha256": "df7b2b39a4577fbe33f63d916ef4e0592fea0db8bc542b7e3f65bf8fca137950" + }, + "Init.Data.String": { + "relative_path": "lib/lean/Init/Data/String.olean", + "sha256": "44d46641afe72049132e8ba521b7e404190fb50b1710a008a531a6cb4bce4308" + }, + "Init.Data.String.Basic": { + "relative_path": "lib/lean/Init/Data/String/Basic.olean", + "sha256": "d7404ec9c0cedeb3e77cc7eadc3201e7cf1d44e1029407a279ce5dd2ab5537d1" + }, + "Init.Data.String.Extra": { + "relative_path": "lib/lean/Init/Data/String/Extra.olean", + "sha256": "5291234dedeae61b8f31129e9e8d90fcc2b91a784384250d36eea11c694e359a" + }, + "Init.Data.String.Lemmas": { + "relative_path": "lib/lean/Init/Data/String/Lemmas.olean", + "sha256": "e2fa260513d3ccaba3d0547bc5625ebbe09a171762e375b38b6dc1b8dc0fa6f5" + }, + "Init.Data.Subtype": { + "relative_path": "lib/lean/Init/Data/Subtype.olean", + "sha256": "1278a669b084dabde55a3f9a14c8b3ea7b7753b4b4d52bdbc1066bcb29f30208" + }, + "Init.Data.Sum": { + "relative_path": "lib/lean/Init/Data/Sum.olean", + "sha256": "0c08e5312a75c9474abf94ce7f6358efbdc6c178476005e36c22b5b294647930" + }, + "Init.Data.Sum.Basic": { + "relative_path": "lib/lean/Init/Data/Sum/Basic.olean", + "sha256": "30b5a85e6941f567feb412f1e6a4382d5c6d52558c4657285e80bd1b58879427" + }, + "Init.Data.Sum.Lemmas": { + "relative_path": "lib/lean/Init/Data/Sum/Lemmas.olean", + "sha256": "01ce321477e3f24f07aca5b0c4423c46d4c4e9533f25e00cdfd3f7e0af9ba319" + }, + "Init.Data.ToString": { + "relative_path": "lib/lean/Init/Data/ToString.olean", + "sha256": "bf141c2b4f750f8154aff447a05b8c02fc0231c48e550bf29823dd3a101b60a6" + }, + "Init.Data.ToString.Basic": { + "relative_path": "lib/lean/Init/Data/ToString/Basic.olean", + "sha256": "0892126af7fd71f9dd48a1f051af4f1ca5f181389a9b97dd7c759abcb8088fd0" + }, + "Init.Data.ToString.Macro": { + "relative_path": "lib/lean/Init/Data/ToString/Macro.olean", + "sha256": "3284b8ed0d3883ba46d39abb4d3620820bf6f12e47bfe3f33ead82ad80039580" + }, + "Init.Data.UInt": { + "relative_path": "lib/lean/Init/Data/UInt.olean", + "sha256": "a92781a10cb664f3b9dc344957d3c5c95bf9ec44fbe192cbb6ceac4c1d9f1391" + }, + "Init.Data.UInt.Basic": { + "relative_path": "lib/lean/Init/Data/UInt/Basic.olean", + "sha256": "d30c2c0bff573487362546d06fe7cf8fc0ae6dfead1379a1ad2523fc96795eb9" + }, + "Init.Data.UInt.BasicAux": { + "relative_path": "lib/lean/Init/Data/UInt/BasicAux.olean", + "sha256": "76e27df77fe31ef1d6b54d00a1758d579532a15787f4cfec7da774d535b47072" + }, + "Init.Data.UInt.Bitwise": { + "relative_path": "lib/lean/Init/Data/UInt/Bitwise.olean", + "sha256": "aa829cd7c8a6e68d0365d1662727646fc68b817428e469b33d96d057f6643d4e" + }, + "Init.Data.UInt.Lemmas": { + "relative_path": "lib/lean/Init/Data/UInt/Lemmas.olean", + "sha256": "5912f89a17ba6b111d9d7f3df46904b90811a4cdd80fc02a06984cd4c3dd3aa0" + }, + "Init.Data.UInt.Log2": { + "relative_path": "lib/lean/Init/Data/UInt/Log2.olean", + "sha256": "315c374ceeecdab0fde8042abffb68b082f063ce3ebf810efa46d89eb239faca" + }, + "Init.Data.ULift": { + "relative_path": "lib/lean/Init/Data/ULift.olean", + "sha256": "e1187f01e60437dc3c741cd1ba76657855642cc2574a59fa9a3be9a9e9d435b4" + }, + "Init.Data.Vector": { + "relative_path": "lib/lean/Init/Data/Vector.olean", + "sha256": "8ff79e5ffafceccc1bc38f3ac3d5ae7eb802c95cf1bd51393c6af7be6dfdea63" + }, + "Init.Data.Vector.Attach": { + "relative_path": "lib/lean/Init/Data/Vector/Attach.olean", + "sha256": "ecf089f945d2adcc57180f779593ccf0a2fa0c27d89968a7722b914f4b58b8af" + }, + "Init.Data.Vector.Basic": { + "relative_path": "lib/lean/Init/Data/Vector/Basic.olean", + "sha256": "afacc92812490337d7f03950905748563477bfe6494f046a0dfd9451aa4a4d65" + }, + "Init.Data.Vector.Count": { + "relative_path": "lib/lean/Init/Data/Vector/Count.olean", + "sha256": "b23fa70c6a9f0ea3b8ed1a4c811a2d0557751d4bb798e954d1ff985e00d492b1" + }, + "Init.Data.Vector.DecidableEq": { + "relative_path": "lib/lean/Init/Data/Vector/DecidableEq.olean", + "sha256": "4cf94f33d63c842c39f35392ce1bbf4c40ed1bfe9ec5161d522ba1442d8e0a2c" + }, + "Init.Data.Vector.Erase": { + "relative_path": "lib/lean/Init/Data/Vector/Erase.olean", + "sha256": "8c5cf30ba1225d74d85f93b3553f09e9299c182805f0efb44fad509ea5e56b78" + }, + "Init.Data.Vector.Extract": { + "relative_path": "lib/lean/Init/Data/Vector/Extract.olean", + "sha256": "0e12201859d76ac91415a74e00f909b32a631fefd2d2b5d7afeb0d2730bfa47a" + }, + "Init.Data.Vector.FinRange": { + "relative_path": "lib/lean/Init/Data/Vector/FinRange.olean", + "sha256": "b862166a52500e392a3cfab1b4b4f5d2b7b202725f48526a1e935ca52abdda38" + }, + "Init.Data.Vector.InsertIdx": { + "relative_path": "lib/lean/Init/Data/Vector/InsertIdx.olean", + "sha256": "c3f496caa69211325d18bc909f9be134bfd07515f8b95773b252004a71e01fc5" + }, + "Init.Data.Vector.Lemmas": { + "relative_path": "lib/lean/Init/Data/Vector/Lemmas.olean", + "sha256": "35726f2c825e29355e25d574a25470dba908ea9f680b92f4e6ab57ec77d47f3d" + }, + "Init.Data.Vector.Lex": { + "relative_path": "lib/lean/Init/Data/Vector/Lex.olean", + "sha256": "1541eb5302ac1fe618815bd36a3d4468f08003a6571118fc8322bbf155b441de" + }, + "Init.Data.Vector.MapIdx": { + "relative_path": "lib/lean/Init/Data/Vector/MapIdx.olean", + "sha256": "cbe812bbd7839fae0178d0c183d96d1f29f768b55349bebb47628f903c7cda57" + }, + "Init.Data.Vector.Monadic": { + "relative_path": "lib/lean/Init/Data/Vector/Monadic.olean", + "sha256": "c44bb39a17f785673f64d6e40116173d821d9184c41377371c5cb73565440a30" + }, + "Init.Data.Vector.OfFn": { + "relative_path": "lib/lean/Init/Data/Vector/OfFn.olean", + "sha256": "69f88342bdd241ebafeffb51ee94c1363ab096ea6d435ef4d062b1a552167cf4" + }, + "Init.Data.Vector.Range": { + "relative_path": "lib/lean/Init/Data/Vector/Range.olean", + "sha256": "88351024a2b10fd4648a0ae15e005d8799b95be7d0060c89a5a205a4fc40b56f" + }, + "Init.Data.Vector.Zip": { + "relative_path": "lib/lean/Init/Data/Vector/Zip.olean", + "sha256": "8c28067d8d5289ec3a5cbc9674643c688210c75813c69c0b66baba5ea29abaea" + }, + "Init.Data.Zero": { + "relative_path": "lib/lean/Init/Data/Zero.olean", + "sha256": "04d070309e7a1962ebcb5de2b2bfa69e5f5d4d54477689cbdbadb21202611dac" + }, + "Init.Dynamic": { + "relative_path": "lib/lean/Init/Dynamic.olean", + "sha256": "a9982d28dff48820a4e5310d473b53d19de91c1d1685749bccb849e881219fa1" + }, + "Init.Ext": { + "relative_path": "lib/lean/Init/Ext.olean", + "sha256": "1f32591106d111c224423e61d0afd89014b96aa77e9141c6bec47b33b80c31f7" + }, + "Init.GetElem": { + "relative_path": "lib/lean/Init/GetElem.olean", + "sha256": "2683b27cced90b5fbfbe5213c309ed94bf423edf90924a1002eea72b152fdb58" + }, + "Init.Grind": { + "relative_path": "lib/lean/Init/Grind.olean", + "sha256": "33eff60d5cea8bd5db12879a12cf1a1cf772b1a2ab778136cc138685bc23654a" + }, + "Init.Grind.Cases": { + "relative_path": "lib/lean/Init/Grind/Cases.olean", + "sha256": "d086d84578922287a95fedee2f43e884a629e838c2ff8e71efc2910510509594" + }, + "Init.Grind.Lemmas": { + "relative_path": "lib/lean/Init/Grind/Lemmas.olean", + "sha256": "ca22a5c6a54190290fc558e7805244c66c3c044c3a708a98300703d70bef11ec" + }, + "Init.Grind.Norm": { + "relative_path": "lib/lean/Init/Grind/Norm.olean", + "sha256": "3f889971f8415ffff0f737c2214d5be92be1294398624aec1c9d9bd45942dd66" + }, + "Init.Grind.Offset": { + "relative_path": "lib/lean/Init/Grind/Offset.olean", + "sha256": "4f95e7282b636fe3690d8b159425a37bf5bb2f80c49e7ccdd6170b6977148d50" + }, + "Init.Grind.PP": { + "relative_path": "lib/lean/Init/Grind/PP.olean", + "sha256": "d94c99691443ce7517096899dc89ffd3a1eff62b621e530ff98e46ff7a9e4407" + }, + "Init.Grind.Propagator": { + "relative_path": "lib/lean/Init/Grind/Propagator.olean", + "sha256": "e292ef4b9a9a4475f7c6eb767ddc84d8b5f0a30feabbbb1664966930e050496f" + }, + "Init.Grind.Tactics": { + "relative_path": "lib/lean/Init/Grind/Tactics.olean", + "sha256": "8c21109288355c0969f3fae78c66756b2a73699d4170d53336d0825a82b2b82d" + }, + "Init.Grind.Util": { + "relative_path": "lib/lean/Init/Grind/Util.olean", + "sha256": "666cf848a9a3ba30885be219a767d96bd2b6582fde19f84110c3c583308c5e8f" + }, + "Init.Guard": { + "relative_path": "lib/lean/Init/Guard.olean", + "sha256": "3bec2e0ab8c2829d1d13c64c80fb983b5d5f115a67b29ee64eedbe3f6628a470" + }, + "Init.Hints": { + "relative_path": "lib/lean/Init/Hints.olean", + "sha256": "5c814650ff2f23259cc67c04ab1a438222ec084d4369aca679fd0cc07cbb5474" + }, + "Init.Internal": { + "relative_path": "lib/lean/Init/Internal.olean", + "sha256": "2927550a155fb6115ac63e31cc35f9969047a6c015ced8325ce769d5631c0200" + }, + "Init.Internal.Order": { + "relative_path": "lib/lean/Init/Internal/Order.olean", + "sha256": "37884830614f3f48f325497beadc3cc60f0e363a1846cdcc28221ca05ba39759" + }, + "Init.Internal.Order.Basic": { + "relative_path": "lib/lean/Init/Internal/Order/Basic.olean", + "sha256": "c0b362116c8f553cc59964154fdc9a3418672bf9b5caee2b745608f40aa71091" + }, + "Init.Internal.Order.Lemmas": { + "relative_path": "lib/lean/Init/Internal/Order/Lemmas.olean", + "sha256": "198fb9d38168f2116937d641fa5419c99e0e9c03c0f630756f68affca451c1e0" + }, + "Init.Internal.Order.Tactic": { + "relative_path": "lib/lean/Init/Internal/Order/Tactic.olean", + "sha256": "d519c1d64b866e639de30ef452587bbe8802c64536e6ee541e47fcc7be3f942d" + }, + "Init.MacroTrace": { + "relative_path": "lib/lean/Init/MacroTrace.olean", + "sha256": "49d356d5728ea1a0ed6a14cbca10b6387f99d40b85602189566c4e4c1d6cc524" + }, + "Init.Meta": { + "relative_path": "lib/lean/Init/Meta.olean", + "sha256": "16b7ad338addb717e0eb584fc583a2e9d4e08242040654a2d3546650cb71bddc" + }, + "Init.MetaTypes": { + "relative_path": "lib/lean/Init/MetaTypes.olean", + "sha256": "1aa89a88743c9d8f66daecc6f28a7a7816efad55a42129bca1e2220450747bd8" + }, + "Init.Notation": { + "relative_path": "lib/lean/Init/Notation.olean", + "sha256": "576706b70dc9f21b093c7b10755e25c2f3fea8f04586b128893308730d715dae" + }, + "Init.NotationExtra": { + "relative_path": "lib/lean/Init/NotationExtra.olean", + "sha256": "92ba272c0a25c97e7800cdf2e948bb20e374861d28d31736d80a757b7dd852b0" + }, + "Init.Omega": { + "relative_path": "lib/lean/Init/Omega.olean", + "sha256": "ef46ae7141263a8f3168ddc0de5b10c37cd991f907e6558d6a10daed027950ad" + }, + "Init.Omega.Coeffs": { + "relative_path": "lib/lean/Init/Omega/Coeffs.olean", + "sha256": "a7f2688fb1799c93744fb62301026c37c58ee81d58eb91e80041622397bd1dd3" + }, + "Init.Omega.Constraint": { + "relative_path": "lib/lean/Init/Omega/Constraint.olean", + "sha256": "1e5a89907d661084e3223c006975f275efbe03df7c43fd18a68425798ac09189" + }, + "Init.Omega.Int": { + "relative_path": "lib/lean/Init/Omega/Int.olean", + "sha256": "335df595a7449bc9ab310b9a5914bcae3ad6219121cd1f67261deb8383b5d61d" + }, + "Init.Omega.IntList": { + "relative_path": "lib/lean/Init/Omega/IntList.olean", + "sha256": "315f3755c1bdb87eda3449e97cb3141b9bc69b88af3faa93b0c54a5bf16137bf" + }, + "Init.Omega.LinearCombo": { + "relative_path": "lib/lean/Init/Omega/LinearCombo.olean", + "sha256": "6f254b2ed1ea5d35519b633f58da229500dca18293b3d958c7f93cc6a7e64e67" + }, + "Init.Omega.Logic": { + "relative_path": "lib/lean/Init/Omega/Logic.olean", + "sha256": "c8b7e60bd2aeee6efbab4f4787a5eddcb8b6ccb02841b7948b5120b5dbc7f5be" + }, + "Init.Prelude": { + "relative_path": "lib/lean/Init/Prelude.olean", + "sha256": "db4e87c0006f1303f3d41ca9a615a4890ca94309812bda09476677ea9bb5d672" + }, + "Init.PropLemmas": { + "relative_path": "lib/lean/Init/PropLemmas.olean", + "sha256": "f95cab4646f43dbaca3fc915bbd32868f0ac73aaeba818d165843e276499542e" + }, + "Init.RCases": { + "relative_path": "lib/lean/Init/RCases.olean", + "sha256": "aa216281d8930fe16cdb7b6b1f604066e824b33eaf62870d41391040c2ba77b4" + }, + "Init.ShareCommon": { + "relative_path": "lib/lean/Init/ShareCommon.olean", + "sha256": "c2647e2778a9bf01ffdc302ea5604308036ee982de23feac85ce21805f0b3ba8" + }, + "Init.SimpLemmas": { + "relative_path": "lib/lean/Init/SimpLemmas.olean", + "sha256": "37b58f69317f08a8e55d1f3950c4d00ccb29ebed135eb5e9789e8feb4f412369" + }, + "Init.Simproc": { + "relative_path": "lib/lean/Init/Simproc.olean", + "sha256": "53b36872b429c61141ac340011f233e680f82ccced2fb43fabf9fbeca5807040" + }, + "Init.SizeOf": { + "relative_path": "lib/lean/Init/SizeOf.olean", + "sha256": "0b2e2a18d9b699a5236c79acca835fd68f5400bbd998ca5743825c5734b6d589" + }, + "Init.SizeOfLemmas": { + "relative_path": "lib/lean/Init/SizeOfLemmas.olean", + "sha256": "ef5ba22b92506575f987eaea9cb87eda5a1d870da071e53f1257cb1cc999fd85" + }, + "Init.Syntax": { + "relative_path": "lib/lean/Init/Syntax.olean", + "sha256": "55eab3582563a12c40c7797ed6d06db613c855508c3138df975d2613422f6399" + }, + "Init.System": { + "relative_path": "lib/lean/Init/System.olean", + "sha256": "7a0e2f92d28211ac4da2835c7b15db71b08799d68e0c759c0f899b7c19ef564c" + }, + "Init.System.FilePath": { + "relative_path": "lib/lean/Init/System/FilePath.olean", + "sha256": "cdc4f4ecf0cd8470047e8c1e706d22f7321bee3072e44a669481e56689e187f1" + }, + "Init.System.IO": { + "relative_path": "lib/lean/Init/System/IO.olean", + "sha256": "069217c5d17f79433867ec6f701a5702cb40c88485dedc61be1f1ce0ef9b44fb" + }, + "Init.System.IOError": { + "relative_path": "lib/lean/Init/System/IOError.olean", + "sha256": "6e1ff344b12e6d7fcbb7abea99eaa3c88ae2626dd669d7f3c545822f96494ec2" + }, + "Init.System.Mutex": { + "relative_path": "lib/lean/Init/System/Mutex.olean", + "sha256": "fc950b4b00a1c3104ea945a9a93ab51807521b29a0b83518127de77eb3f76922" + }, + "Init.System.Platform": { + "relative_path": "lib/lean/Init/System/Platform.olean", + "sha256": "b679564c6df441632b6277f089cd588220ae5c4b8ae519873dc3172bb3091e52" + }, + "Init.System.Promise": { + "relative_path": "lib/lean/Init/System/Promise.olean", + "sha256": "78dc6c800d0f873e6520dbcf32c9dda22370563c75f086fb03e25fae393e848c" + }, + "Init.System.ST": { + "relative_path": "lib/lean/Init/System/ST.olean", + "sha256": "3fc620f17a5cb9e2243d760ffcb7ede9227b8c639c9376ff25c6bea1a7c1a7e7" + }, + "Init.System.Uri": { + "relative_path": "lib/lean/Init/System/Uri.olean", + "sha256": "d1a020ceeb21e6358fb0768345f90866752ef2dfe6c9dec71f388bd34b919de3" + }, + "Init.Tactics": { + "relative_path": "lib/lean/Init/Tactics.olean", + "sha256": "285e86e84ef77045b1f4944cacef6f11bca49334671808adec30f2e6fafd0dd8" + }, + "Init.TacticsExtra": { + "relative_path": "lib/lean/Init/TacticsExtra.olean", + "sha256": "e0521889dab4e1a74e8a407a0a0409109723ab9363b4be234115dc80aa01b5ba" + }, + "Init.Task": { + "relative_path": "lib/lean/Init/Task.olean", + "sha256": "effc51f55f006a6e54f0bb4b6577f7fe6a92d79958a0f3dfd258e4c53b9fa3c8" + }, + "Init.Try": { + "relative_path": "lib/lean/Init/Try.olean", + "sha256": "d289104c53a554fd4e7d8b81d5fd8212dcca854e6dec5cf80e088e3545a23c6b" + }, + "Init.Util": { + "relative_path": "lib/lean/Init/Util.olean", + "sha256": "da825c487c1ff3bf957f8ef84fade6ca10e2428807f84f52613551e11a404f03" + }, + "Init.WF": { + "relative_path": "lib/lean/Init/WF.olean", + "sha256": "16d58f1a3442679940e0f5d0eb9fd209e6eae04f7f4550dd7361847f0ba97082" + }, + "Init.WFTactics": { + "relative_path": "lib/lean/Init/WFTactics.olean", + "sha256": "edeb5134b3fc1f3234ef027a4d803b733c75a7174ac2a4bfe8a6353f783deb32" + }, + "Init.While": { + "relative_path": "lib/lean/Init/While.olean", + "sha256": "6fc8fbe7c581376a6826126ce6aacb031231cdc32afb135dfa3bfda884305625" + }, + "Lean": { + "relative_path": "lib/lean/Lean.olean", + "sha256": "7b09317fc9d21262dbfbb6f014dc40c2809b55e6cbb4f7587211a57ec91f7221" + }, + "Lean.AddDecl": { + "relative_path": "lib/lean/Lean/AddDecl.olean", + "sha256": "ec30e087524b32520021eeb3dc8c2d0aefdce838f11dd8e57f13cf1f05611cf8" + }, + "Lean.Attributes": { + "relative_path": "lib/lean/Lean/Attributes.olean", + "sha256": "e4db4a704b0260d6e36f4f542416091124e09767dc8bc759d2b1adbe53e9c166" + }, + "Lean.AuxRecursor": { + "relative_path": "lib/lean/Lean/AuxRecursor.olean", + "sha256": "8ad6ecf040763b62561819bb75de71763765566d01e68d3ed60fe27ff1b70b92" + }, + "Lean.BuiltinDocAttr": { + "relative_path": "lib/lean/Lean/BuiltinDocAttr.olean", + "sha256": "c9fb01241ff340cc8cdba6efffa553449f24748d42f0966903ce7b3038a6f266" + }, + "Lean.Class": { + "relative_path": "lib/lean/Lean/Class.olean", + "sha256": "0a41587a7d43178adb832ac6a835a3ded745f5b94f031b8a7fa916a6de2d681c" + }, + "Lean.Compiler": { + "relative_path": "lib/lean/Lean/Compiler.olean", + "sha256": "60a1e6cb63d9ee93f449d816b9d5f35d550da07c2ed98d4574cc00610aaa1fcc" + }, + "Lean.Compiler.AtMostOnce": { + "relative_path": "lib/lean/Lean/Compiler/AtMostOnce.olean", + "sha256": "46d86c6dc85f433a42dfa3a3162ed82530e0efd6d0def6857c447342776280b5" + }, + "Lean.Compiler.BorrowedAnnotation": { + "relative_path": "lib/lean/Lean/Compiler/BorrowedAnnotation.olean", + "sha256": "dfd99a6b65e28ce3c81d6effb32273e088fcce5829cbaeec57a98a4f325c70a8" + }, + "Lean.Compiler.CSimpAttr": { + "relative_path": "lib/lean/Lean/Compiler/CSimpAttr.olean", + "sha256": "4228ef18768f8fd70d1c48c5a5e9c7e0736e84389e0cc291d45ea6ef55853c85" + }, + "Lean.Compiler.ClosedTermCache": { + "relative_path": "lib/lean/Lean/Compiler/ClosedTermCache.olean", + "sha256": "332d9fcc102a8ec05d9d450f835de662c8b153274e86f4e8f8bf72bb7c0c86fa" + }, + "Lean.Compiler.ConstFolding": { + "relative_path": "lib/lean/Lean/Compiler/ConstFolding.olean", + "sha256": "a0f0396a65891075ef27848bf3578a2b14c5d9fa295ee982014d97cae25ec46c" + }, + "Lean.Compiler.ExportAttr": { + "relative_path": "lib/lean/Lean/Compiler/ExportAttr.olean", + "sha256": "f0975b5550d69d83ad3b27d0ad2363641167e47178788f22890be83d3e5511e6" + }, + "Lean.Compiler.ExternAttr": { + "relative_path": "lib/lean/Lean/Compiler/ExternAttr.olean", + "sha256": "c015f64d0e192ec7b6774ea02f82e8d210aa29022cc9317ba1f44f4d1db03983" + }, + "Lean.Compiler.FFI": { + "relative_path": "lib/lean/Lean/Compiler/FFI.olean", + "sha256": "5c592270389ca3547b225d542569d17074a72aab1d3069972aa13183c9defb4b" + }, + "Lean.Compiler.IR": { + "relative_path": "lib/lean/Lean/Compiler/IR.olean", + "sha256": "c0d443734bf92a204df7d44fb5b213073d860465d1940beb4f56be04fe95fa5d" + }, + "Lean.Compiler.IR.Basic": { + "relative_path": "lib/lean/Lean/Compiler/IR/Basic.olean", + "sha256": "256c663d51575e663739cf47717d5b563d91bccd233443d8c71ff95eb81ccf2b" + }, + "Lean.Compiler.IR.Borrow": { + "relative_path": "lib/lean/Lean/Compiler/IR/Borrow.olean", + "sha256": "76ccf72d60d34df08de11583942e4978c88f79daea6c48a34aee9b0b0164a143" + }, + "Lean.Compiler.IR.Boxing": { + "relative_path": "lib/lean/Lean/Compiler/IR/Boxing.olean", + "sha256": "ba56d60339b940f7b1d5f1bc244145dd90c835bd7a7c22501af7ab4eb502c7e9" + }, + "Lean.Compiler.IR.Checker": { + "relative_path": "lib/lean/Lean/Compiler/IR/Checker.olean", + "sha256": "0760b0f827e3f94462f855b0cde1e99a4f2ececa4dc914bb36ccc7388d05ea1f" + }, + "Lean.Compiler.IR.CompilerM": { + "relative_path": "lib/lean/Lean/Compiler/IR/CompilerM.olean", + "sha256": "3c51c9bc8b5684d2b997424a46ecfffd0faebaeccc20871faa6142bbdee6261e" + }, + "Lean.Compiler.IR.CtorLayout": { + "relative_path": "lib/lean/Lean/Compiler/IR/CtorLayout.olean", + "sha256": "41b6538779aec55878034a4311f5ec5afb609ee355306207f63d480beec7d8f1" + }, + "Lean.Compiler.IR.ElimDeadBranches": { + "relative_path": "lib/lean/Lean/Compiler/IR/ElimDeadBranches.olean", + "sha256": "db8b2361ec98aeab4251a3f24b6bdd6dfea6560736a7e2db580ac80ea5a19088" + }, + "Lean.Compiler.IR.ElimDeadVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/ElimDeadVars.olean", + "sha256": "fa545c9536767b2921812ec4f12787dbafdb12fba219c37c50ef08406aed35c0" + }, + "Lean.Compiler.IR.EmitC": { + "relative_path": "lib/lean/Lean/Compiler/IR/EmitC.olean", + "sha256": "8d3cc7f7314b0540efc952a891d2c04b146a0e974c78698f257aa84218e22fa8" + }, + "Lean.Compiler.IR.EmitUtil": { + "relative_path": "lib/lean/Lean/Compiler/IR/EmitUtil.olean", + "sha256": "d94b654927d21d70638e7be9f071d042f1ddef03ffb35c8e1873ce06f6bc0bec" + }, + "Lean.Compiler.IR.ExpandResetReuse": { + "relative_path": "lib/lean/Lean/Compiler/IR/ExpandResetReuse.olean", + "sha256": "52056b452d80b3cc358d961c340c878bd8fd439c4157f19579ab24b6e45beb63" + }, + "Lean.Compiler.IR.Format": { + "relative_path": "lib/lean/Lean/Compiler/IR/Format.olean", + "sha256": "7ce035303406e57cca579f9730815aae11392a6b068ebfb1ae5563989ef9d648" + }, + "Lean.Compiler.IR.FreeVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/FreeVars.olean", + "sha256": "b7689c40b2b8acb573130f0678e945f7de1f93cc0d2cc516992b735d3b16600c" + }, + "Lean.Compiler.IR.LiveVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/LiveVars.olean", + "sha256": "04dffa3befd0baf2b1caabada126812e8799e0842e88ae55d2f9f435b210bba7" + }, + "Lean.Compiler.IR.NormIds": { + "relative_path": "lib/lean/Lean/Compiler/IR/NormIds.olean", + "sha256": "42d1c0c091dd6795dc22f817e1bbd69f8a023744028d476ee73c3d47b9094507" + }, + "Lean.Compiler.IR.PushProj": { + "relative_path": "lib/lean/Lean/Compiler/IR/PushProj.olean", + "sha256": "45d3a0ef752e7ec5a2868af25c01793a0e9763307b35d8821fb1aeeb0886e5e7" + }, + "Lean.Compiler.IR.RC": { + "relative_path": "lib/lean/Lean/Compiler/IR/RC.olean", + "sha256": "efe9f4218bc3bc9ff1df43dbd6d5d5629c6914bc69834a1642f67aa16b9c7a1c" + }, + "Lean.Compiler.IR.ResetReuse": { + "relative_path": "lib/lean/Lean/Compiler/IR/ResetReuse.olean", + "sha256": "efe1a6814901274604fe1e6ada5e6819c56a50ade0732c255a5fabbac86b90f0" + }, + "Lean.Compiler.IR.SimpCase": { + "relative_path": "lib/lean/Lean/Compiler/IR/SimpCase.olean", + "sha256": "3c29f2a2fc5a04a44b6afa8c945055dc63aaee07fa17412c49f32b66b93af17b" + }, + "Lean.Compiler.IR.Sorry": { + "relative_path": "lib/lean/Lean/Compiler/IR/Sorry.olean", + "sha256": "4f931aed57566e1db5097e0703d072434871fcfad52bedd7afefda28c9e28b49" + }, + "Lean.Compiler.IR.UnboxResult": { + "relative_path": "lib/lean/Lean/Compiler/IR/UnboxResult.olean", + "sha256": "7a27c69a4b077ee78cd5c060dab56b7af05e02428073627d28ccdff330e74670" + }, + "Lean.Compiler.ImplementedByAttr": { + "relative_path": "lib/lean/Lean/Compiler/ImplementedByAttr.olean", + "sha256": "0bdd1c11d87a3e766eb8372e72dbdc72606b0367551455d1ff3093d50a14ba0e" + }, + "Lean.Compiler.InitAttr": { + "relative_path": "lib/lean/Lean/Compiler/InitAttr.olean", + "sha256": "a4b773a972dd41b77fa8973f7c570e3c2f1eef2a56e36c6b5b91a9543fe23efd" + }, + "Lean.Compiler.InlineAttrs": { + "relative_path": "lib/lean/Lean/Compiler/InlineAttrs.olean", + "sha256": "1dc521edbac6c28fb0abe0b1bfa72372d225b00d184228cb135fea3b3900583c" + }, + "Lean.Compiler.LCNF": { + "relative_path": "lib/lean/Lean/Compiler/LCNF.olean", + "sha256": "50ba85811e79db199dcc8528997fe62c599b3e36bae0bff0c56da744a975815e" + }, + "Lean.Compiler.LCNF.AlphaEqv": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/AlphaEqv.olean", + "sha256": "3e525daf1858d10b3c576598392a797f9bc77af47c88877a81f4b80f95e39f60" + }, + "Lean.Compiler.LCNF.AuxDeclCache": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/AuxDeclCache.olean", + "sha256": "e4ebfeac04cc04ab322e324c6b5cceb5fb0049899d323ace2185ed1d82f20460" + }, + "Lean.Compiler.LCNF.BaseTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/BaseTypes.olean", + "sha256": "5053822e35b6065475c75ea4121fb7c0e5572473b589a6318c23d8245cb91031" + }, + "Lean.Compiler.LCNF.Basic": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Basic.olean", + "sha256": "61a9c336f3fc892426f33ce054488c33e6c853038561acc10f6e68f1c4dae86f" + }, + "Lean.Compiler.LCNF.Bind": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Bind.olean", + "sha256": "ddcb0976ae13b967a67b86197dd84df7911382cfc311cc72f1643bcde382170e" + }, + "Lean.Compiler.LCNF.CSE": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CSE.olean", + "sha256": "0f30cf963d74e913c63d6a61eb2e6024a51aae3598e1bb7d67fe68e2571983b1" + }, + "Lean.Compiler.LCNF.Check": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Check.olean", + "sha256": "bfa8071c59de426aaa04e96c0c7cc9adabcba58266af88e878efc333efa217cc" + }, + "Lean.Compiler.LCNF.Closure": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Closure.olean", + "sha256": "8e07eaf84941feda5b4549dcbbfa53cd0981cf41053d3cb7604de6b37055b89c" + }, + "Lean.Compiler.LCNF.CompatibleTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CompatibleTypes.olean", + "sha256": "bbbd5d8598de30d40edc079da53afced3be253be5f5bc1ba5098b673a39178a7" + }, + "Lean.Compiler.LCNF.CompilerM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CompilerM.olean", + "sha256": "0dba55f8281250c8f7c8ca16d327e9c699a12bc22b7a740cc4494c9807071148" + }, + "Lean.Compiler.LCNF.ConfigOptions": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ConfigOptions.olean", + "sha256": "911b57609345802250709851c15ca20bb8b0c72d7cd38eb43691c09523cec4a7" + }, + "Lean.Compiler.LCNF.DeclHash": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/DeclHash.olean", + "sha256": "5e269b1f1ac7904fb9ebb77fe9805065fbb378fecf06eef5f123dc27a84b8555" + }, + "Lean.Compiler.LCNF.DependsOn": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/DependsOn.olean", + "sha256": "e7d096fac73063f27b1fc6f49c0eb5c4b7edb7075115cae9f2635e894fc7b070" + }, + "Lean.Compiler.LCNF.ElimDead": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ElimDead.olean", + "sha256": "477333313db8979680b9ee364d3075b5162225b83a69c60f18afca99f5f184c9" + }, + "Lean.Compiler.LCNF.ElimDeadBranches": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ElimDeadBranches.olean", + "sha256": "67ca5f89e780bfa7c0e62c0318b038421385dd3d9165ee207e2ba55a8edc3b50" + }, + "Lean.Compiler.LCNF.FVarUtil": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FVarUtil.olean", + "sha256": "d15ee92fbc441d2a5805f9fd5f851c49dd7267fc259d058273771168ce44b2b4" + }, + "Lean.Compiler.LCNF.FixedParams": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FixedParams.olean", + "sha256": "02e113791b21bc00471cc5e650e0167187e9b60993dc1627c1a0591cf9e928dc" + }, + "Lean.Compiler.LCNF.FloatLetIn": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FloatLetIn.olean", + "sha256": "aa1a425efb344b0216c4d87f584165e314acc54702788de99d359010f51cd5ef" + }, + "Lean.Compiler.LCNF.InferType": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/InferType.olean", + "sha256": "b91d6fbb425074a2e8296fbc557159c22b409e8f2ffa2dcf554f17d8d40f43fc" + }, + "Lean.Compiler.LCNF.Internalize": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Internalize.olean", + "sha256": "ddf26e1a280b6fcf208f46ca6683ffe8ef366527c447557a8852ba581abab6ff" + }, + "Lean.Compiler.LCNF.JoinPoints": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/JoinPoints.olean", + "sha256": "7955fd7fbf4caccbfc179059f5821358b5155dcce356bf20dbc5465989d12831" + }, + "Lean.Compiler.LCNF.LCtx": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/LCtx.olean", + "sha256": "798958fc2fdf1ff92063e6a5696a66dd32273a5eb6e04bfb217759105882742a" + }, + "Lean.Compiler.LCNF.LambdaLifting": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/LambdaLifting.olean", + "sha256": "16f7b519cd8548d6a88aff2c02029440110f13b2b009fb26afa4e8018d76f106" + }, + "Lean.Compiler.LCNF.Level": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Level.olean", + "sha256": "0ff39a4eec80e3c8047e926f4843c44eea5c1516e24c059c1c941d0948df7a6b" + }, + "Lean.Compiler.LCNF.Main": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Main.olean", + "sha256": "3678ef37331fb5a8b609a8ebfae188c589e87fef79ffff24533ea4059160f40c" + }, + "Lean.Compiler.LCNF.MonadScope": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/MonadScope.olean", + "sha256": "b16649d04910e51525f2513891c35417ccc791a9d19331355aea31cdbbe72a2e" + }, + "Lean.Compiler.LCNF.MonoTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/MonoTypes.olean", + "sha256": "6135eec86d64970beb3d9b00a2b74b30c0401784884cde565eefe186f42c7dac" + }, + "Lean.Compiler.LCNF.OtherDecl": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/OtherDecl.olean", + "sha256": "3cd7c6d125c8127901949761c55b36ebc963b7f28047fbb67221f978b966d0d0" + }, + "Lean.Compiler.LCNF.PassManager": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PassManager.olean", + "sha256": "0e7573909dd4940a95abface78fa3660072b1c6163a859562aec0e48c85451cf" + }, + "Lean.Compiler.LCNF.Passes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Passes.olean", + "sha256": "4b8864ccdfb3dabe28940e0e21f1726c3bbb252371c38e7992852f7da95ad0c9" + }, + "Lean.Compiler.LCNF.PhaseExt": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PhaseExt.olean", + "sha256": "8ed93f368be15928b930d48136cac9cac5eb283d269b53a4ccf9dc915480564c" + }, + "Lean.Compiler.LCNF.PrettyPrinter": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PrettyPrinter.olean", + "sha256": "484d0ba585c4943205d33a53df8d4735f52e7b4c65f9cc39a2dadece7e3ee769" + }, + "Lean.Compiler.LCNF.PullFunDecls": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PullFunDecls.olean", + "sha256": "20c18b55f55cc4cf61b95e3be8c6e2c2c1ce63af493e30d543534faf53550bc7" + }, + "Lean.Compiler.LCNF.PullLetDecls": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PullLetDecls.olean", + "sha256": "848f051bce9b922816355c97fc84232a03f85ed5fa38feed1b12ec6ff07eacac" + }, + "Lean.Compiler.LCNF.ReduceArity": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ReduceArity.olean", + "sha256": "bfb8fba4b4cf6829d092a9f3f4b5807108f7110296e6a9f71ceeb1f6ec90cd43" + }, + "Lean.Compiler.LCNF.ReduceJpArity": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ReduceJpArity.olean", + "sha256": "9bb32eeb3214ac55e1013ad425fd0c6852607391296751fddc2b8f4553f68c3e" + }, + "Lean.Compiler.LCNF.Renaming": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Renaming.olean", + "sha256": "bddac036add967291692acef307d3315af8aed4fd89a18d34311ac694ecf7816" + }, + "Lean.Compiler.LCNF.ScopeM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ScopeM.olean", + "sha256": "28822aa06f00730aba221eb7ae6cb264bb494bf25280246ffe6ff36c76243d28" + }, + "Lean.Compiler.LCNF.Simp": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp.olean", + "sha256": "58be16412a7c090265590410396a8263ede4d980f046637dff96f4a94d5d0b43" + }, + "Lean.Compiler.LCNF.Simp.Basic": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Basic.olean", + "sha256": "0bef1c90ca8bed6f80869aeb298d70671f82c7eec6f32e4576cca8d078d2ddfd" + }, + "Lean.Compiler.LCNF.Simp.Config": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Config.olean", + "sha256": "df3ec1bf55fe323c59d24d9e289dbb55b8e4e153686895cb4c6efbf33e693392" + }, + "Lean.Compiler.LCNF.Simp.ConstantFold": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/ConstantFold.olean", + "sha256": "63f240d9e408f7f34c53731a4b40b6784f639f7df3a130297aa52df6c5868ca3" + }, + "Lean.Compiler.LCNF.Simp.DefaultAlt": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.olean", + "sha256": "c7e68d37f1843b498489140e970e2caaa36548918cae5ddd881236065fdf9dfa" + }, + "Lean.Compiler.LCNF.Simp.DiscrM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/DiscrM.olean", + "sha256": "484a04366395e90ad0b5dd5c692a9e0da30c0918f50cca2ce7dc4459fbd6a590" + }, + "Lean.Compiler.LCNF.Simp.FunDeclInfo": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.olean", + "sha256": "63a8525abb01ee09dcd5fd7bb66fd5d5c9139ec98c9c4622594f19d042b7a81d" + }, + "Lean.Compiler.LCNF.Simp.InlineCandidate": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.olean", + "sha256": "04353a98d60a93bb13f644bc92b81233d665eff28f5e2594d7b7a45ef883572c" + }, + "Lean.Compiler.LCNF.Simp.InlineProj": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineProj.olean", + "sha256": "949390558396b4e92eb72823f8f123ce6a6a310b8e77234bd741d36a8158c1a4" + }, + "Lean.Compiler.LCNF.Simp.JpCases": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/JpCases.olean", + "sha256": "88b4036ff347ff9a1678d5eb585ca362ae0090e9de2b646e2efe90f4dc9a2328" + }, + "Lean.Compiler.LCNF.Simp.Main": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Main.olean", + "sha256": "0ae14b3273b7cb404efb46440a25ac0aaf8e49cd31eb57bea19b7833c219365b" + }, + "Lean.Compiler.LCNF.Simp.SimpM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpM.olean", + "sha256": "df1538b785d0aaa55d1d73ab4b63fd693959896c231a826d39818bddcb6b0d08" + }, + "Lean.Compiler.LCNF.Simp.SimpValue": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpValue.olean", + "sha256": "5de57ce90ffa7ba15734b33a8ad519ee98115c1e83f7ce047fcad5eb03bbe297" + }, + "Lean.Compiler.LCNF.Simp.Used": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Used.olean", + "sha256": "a4983d2052c84460309e9808f3d4518e65f78d7097eb707772abe71ba2bf5e4c" + }, + "Lean.Compiler.LCNF.SpecInfo": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/SpecInfo.olean", + "sha256": "4d9ce851163d5921bf6573eaf6b3d68442709f279fa96b23336b7b32d58a440b" + }, + "Lean.Compiler.LCNF.Specialize": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Specialize.olean", + "sha256": "9ecbcb6a200ec1984ed5231ba427a912a51177fbbfcf2d7ae584aba44397758b" + }, + "Lean.Compiler.LCNF.Testing": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Testing.olean", + "sha256": "8f082e72af8eb9e42eda181444b84c6a71e1a38e65b92e335abe9fda5f77d9cd" + }, + "Lean.Compiler.LCNF.ToDecl": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToDecl.olean", + "sha256": "edd9baf0d9dcc767a237f6ab3d3b8be89f5f7a8486579a61d92f3ee55c85ec8b" + }, + "Lean.Compiler.LCNF.ToExpr": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToExpr.olean", + "sha256": "97eb45572133529cfcd4d6581a8a27c406477191a1b027b7dbc8bbaf45bab62d" + }, + "Lean.Compiler.LCNF.ToLCNF": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToLCNF.olean", + "sha256": "3d2ca7cd028efcacaa2882570d10dd518c5a73860de6ceebb68658b3439607ab" + }, + "Lean.Compiler.LCNF.ToMono": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToMono.olean", + "sha256": "9c42901d6b7192fd65b8a5f809566805abc90063211569894835a17be53820b3" + }, + "Lean.Compiler.LCNF.Types": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Types.olean", + "sha256": "19db15eb19ec6842ff578614e85a7323642539fbb955b5912c170dec0eae2292" + }, + "Lean.Compiler.LCNF.Util": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Util.olean", + "sha256": "2a73fb99a3cb08e8a41425bc5ca182aaaa401508e583d6305a70868ea56208c3" + }, + "Lean.Compiler.Main": { + "relative_path": "lib/lean/Lean/Compiler/Main.olean", + "sha256": "9dc59f3522ff5c16389fc3454829050f7613c2f4175037beab5c0e4f86468de3" + }, + "Lean.Compiler.NameMangling": { + "relative_path": "lib/lean/Lean/Compiler/NameMangling.olean", + "sha256": "52aa954ea4c255de3c15968d309de875c4b03892e28568614f5b9e5d6bc3f38c" + }, + "Lean.Compiler.NeverExtractAttr": { + "relative_path": "lib/lean/Lean/Compiler/NeverExtractAttr.olean", + "sha256": "8efc3ead298e537a086cd425cfd99e6cd10185c78b13d8654d04435ed0f2c577" + }, + "Lean.Compiler.NoncomputableAttr": { + "relative_path": "lib/lean/Lean/Compiler/NoncomputableAttr.olean", + "sha256": "e396574927b99c247f101c8248a0a09cdff7a46e3809fb4589f0dcc4fba6d106" + }, + "Lean.Compiler.Old": { + "relative_path": "lib/lean/Lean/Compiler/Old.olean", + "sha256": "abc232855b58731d54ab07783fa46843208c6deace78b6b370cf476353c3e46d" + }, + "Lean.Compiler.Options": { + "relative_path": "lib/lean/Lean/Compiler/Options.olean", + "sha256": "b86376be11dc414b13c5a54d25cb7817f5660a01981e99d7f45f587f9a2933df" + }, + "Lean.Compiler.Specialize": { + "relative_path": "lib/lean/Lean/Compiler/Specialize.olean", + "sha256": "401294d22aa31d66ffea73cc8e81b84069c82bbf437abe562251e13bfd93394a" + }, + "Lean.CoreM": { + "relative_path": "lib/lean/Lean/CoreM.olean", + "sha256": "5e46337730d7e521a4ee2760c1adaea3e2862c5cc8006afed50f290ca2aafea7" + }, + "Lean.Data": { + "relative_path": "lib/lean/Lean/Data.olean", + "sha256": "3ea6fcf75dec1adae7990d5823a1527d3306689cb440e3c5ecea7b7ea7aab07d" + }, + "Lean.Data.Array": { + "relative_path": "lib/lean/Lean/Data/Array.olean", + "sha256": "d21870a1441bb3b382f82f64457d1fabeb8ab046e4147892433f89143f8481ea" + }, + "Lean.Data.AssocList": { + "relative_path": "lib/lean/Lean/Data/AssocList.olean", + "sha256": "9a08b7424a24c46dd2284b4c7b8692181a5e608302ae500e6445d627ea448d41" + }, + "Lean.Data.DeclarationRange": { + "relative_path": "lib/lean/Lean/Data/DeclarationRange.olean", + "sha256": "0c7a925cebc8a6c0405a7f6741afe5ecebca751b7141fc36518c902615167d6d" + }, + "Lean.Data.Format": { + "relative_path": "lib/lean/Lean/Data/Format.olean", + "sha256": "64c298e5e84c96a54830f2e1cf59e23ecd5c91c45336d9e99aa368884d8a9069" + }, + "Lean.Data.FuzzyMatching": { + "relative_path": "lib/lean/Lean/Data/FuzzyMatching.olean", + "sha256": "558ddc6d5ca38eada259e0fa5ad47478d15ba0f7878a7becb1c04394e7e98b19" + }, + "Lean.Data.Json": { + "relative_path": "lib/lean/Lean/Data/Json.olean", + "sha256": "3839c3f8868485cc28a91248414f8d7b15e3785cadd116d77d254f3acef1b768" + }, + "Lean.Data.Json.Basic": { + "relative_path": "lib/lean/Lean/Data/Json/Basic.olean", + "sha256": "d4a1599c4250412e05b960339e4898b1b5a9dde3f0292029eb02947f7df091cb" + }, + "Lean.Data.Json.Elab": { + "relative_path": "lib/lean/Lean/Data/Json/Elab.olean", + "sha256": "75bd0e3c0b0e50b6890616aff9499849bcc80f783737fb06762b1e638ce6641a" + }, + "Lean.Data.Json.FromToJson": { + "relative_path": "lib/lean/Lean/Data/Json/FromToJson.olean", + "sha256": "bc5266fe22b0d8289fac5e2194f2f3a5c0efa79dc538a96dee258041d8296066" + }, + "Lean.Data.Json.Parser": { + "relative_path": "lib/lean/Lean/Data/Json/Parser.olean", + "sha256": "eb9a4c2f421543848f9e21ff12b4cbf7ec42e0b339c4cc81725e9be627307a46" + }, + "Lean.Data.Json.Printer": { + "relative_path": "lib/lean/Lean/Data/Json/Printer.olean", + "sha256": "18bc6d83251888a60b8e091d5a7cd832d1733cca7cf8fc0afd197db2cd4bac6d" + }, + "Lean.Data.Json.Stream": { + "relative_path": "lib/lean/Lean/Data/Json/Stream.olean", + "sha256": "bbb7aea03b82669971dae676811dc7c4d2f91530d1b95dec8186faad10a2690e" + }, + "Lean.Data.JsonRpc": { + "relative_path": "lib/lean/Lean/Data/JsonRpc.olean", + "sha256": "324ae0dd9b94d607f0bd3634ff28ee91747e533225a1787ccffd3cdff6e78934" + }, + "Lean.Data.KVMap": { + "relative_path": "lib/lean/Lean/Data/KVMap.olean", + "sha256": "b69b36c839f87d7982c58dca02516af56a62b6e6f8cfed957727ab6fa5bdc3ac" + }, + "Lean.Data.LBool": { + "relative_path": "lib/lean/Lean/Data/LBool.olean", + "sha256": "e53d3d54cbdd02e971cade214336ed88039217dac49083fe9e2884774bc65980" + }, + "Lean.Data.LOption": { + "relative_path": "lib/lean/Lean/Data/LOption.olean", + "sha256": "ef57f5ca74f00d15e3353c7372bfd6539fad887f98eeb1405fc120f63fbc5450" + }, + "Lean.Data.Lsp": { + "relative_path": "lib/lean/Lean/Data/Lsp.olean", + "sha256": "5e8f95b054cf4f0bd78d09d3b60f8212677ebbcc9669810a4d555c12dbbe2c9d" + }, + "Lean.Data.Lsp.Basic": { + "relative_path": "lib/lean/Lean/Data/Lsp/Basic.olean", + "sha256": "10bd55152d2d3195bc716586b88ba354117a1610a511d4ef45e5bae4e47da591" + }, + "Lean.Data.Lsp.CancelParams": { + "relative_path": "lib/lean/Lean/Data/Lsp/CancelParams.olean", + "sha256": "34d5045104a2ad488db0eef5506fb5d152a50eb3b218963958249909e0693fc5" + }, + "Lean.Data.Lsp.Capabilities": { + "relative_path": "lib/lean/Lean/Data/Lsp/Capabilities.olean", + "sha256": "ea086554ff056336572f390c3a721392fc0a091b1e3ad5b11a1cbcfde01acb7d" + }, + "Lean.Data.Lsp.Client": { + "relative_path": "lib/lean/Lean/Data/Lsp/Client.olean", + "sha256": "66969eb1b65d7b7c0785a7410441db19c0684e49523b99141c98e9d6de265b1c" + }, + "Lean.Data.Lsp.CodeActions": { + "relative_path": "lib/lean/Lean/Data/Lsp/CodeActions.olean", + "sha256": "aaf6f59e076f612c399dc153b8655c630e5e8d3900d0c34e0754af24363fb5db" + }, + "Lean.Data.Lsp.Communication": { + "relative_path": "lib/lean/Lean/Data/Lsp/Communication.olean", + "sha256": "ff24b3db4d74dee7c02f3b312dfbcd8808ad401059a6e620467de85d2eae4b02" + }, + "Lean.Data.Lsp.Diagnostics": { + "relative_path": "lib/lean/Lean/Data/Lsp/Diagnostics.olean", + "sha256": "fab551e98e02150756f22d91f045edd2885311b0f2acd3b9f2518a03ac5315d1" + }, + "Lean.Data.Lsp.Extra": { + "relative_path": "lib/lean/Lean/Data/Lsp/Extra.olean", + "sha256": "328a92e6483fa971c03bc5c81df3fb8d54638f2b63589227cd51c150c184c6b3" + }, + "Lean.Data.Lsp.InitShutdown": { + "relative_path": "lib/lean/Lean/Data/Lsp/InitShutdown.olean", + "sha256": "6a4a2bdd2b9c291879021e2ac05ebb1766e5261b8eacce52931e0e3456e83582" + }, + "Lean.Data.Lsp.Internal": { + "relative_path": "lib/lean/Lean/Data/Lsp/Internal.olean", + "sha256": "7ac2bdcbc98918536b8dbc74f690ef33efa3d8f262d9da00b9745674124fa0f2" + }, + "Lean.Data.Lsp.Ipc": { + "relative_path": "lib/lean/Lean/Data/Lsp/Ipc.olean", + "sha256": "4655e8e87c7be2dee1388ddf2859e22126ff8e459049c7ae78b1f8c423523f60" + }, + "Lean.Data.Lsp.LanguageFeatures": { + "relative_path": "lib/lean/Lean/Data/Lsp/LanguageFeatures.olean", + "sha256": "9076799ae1e2a126180f4b65b4ba70bd0587000bbba075a49ede2e652940f648" + }, + "Lean.Data.Lsp.TextSync": { + "relative_path": "lib/lean/Lean/Data/Lsp/TextSync.olean", + "sha256": "661e837c6457b276db0fc3ff7b83c025daed1e81f1d119fa2bd8d8f703507212" + }, + "Lean.Data.Lsp.Utf16": { + "relative_path": "lib/lean/Lean/Data/Lsp/Utf16.olean", + "sha256": "3b966b6509a39ebdcfad59afb26a19c8b1ba431328424700a06d2f157e4628a2" + }, + "Lean.Data.Lsp.Window": { + "relative_path": "lib/lean/Lean/Data/Lsp/Window.olean", + "sha256": "80692ee76bcb8185fa3f79531823189b4aec6a02471db5978a0d41c260482632" + }, + "Lean.Data.Lsp.Workspace": { + "relative_path": "lib/lean/Lean/Data/Lsp/Workspace.olean", + "sha256": "9e2c734db08fbbf1a7eecf54afa2f4e6b2c4823fbfec4a700ca1ede9cbf099a8" + }, + "Lean.Data.Name": { + "relative_path": "lib/lean/Lean/Data/Name.olean", + "sha256": "608a86b16dc2e68888780aace6bf3c444be9ca982fbe05c0722b24a5941114cf" + }, + "Lean.Data.NameMap": { + "relative_path": "lib/lean/Lean/Data/NameMap.olean", + "sha256": "ad3950d1e39be7f250a74794819b4c299fd8aad0b95a8ebf383f713c4648667b" + }, + "Lean.Data.NameTrie": { + "relative_path": "lib/lean/Lean/Data/NameTrie.olean", + "sha256": "7b0032738d09c94b21eedfb74e920ce5781c864cc1541e28b9216f2296a3f50a" + }, + "Lean.Data.OpenDecl": { + "relative_path": "lib/lean/Lean/Data/OpenDecl.olean", + "sha256": "11d3c7dfac1707956e6ad5f8d99249971cefd2439d94b1042efcf1147a609848" + }, + "Lean.Data.Options": { + "relative_path": "lib/lean/Lean/Data/Options.olean", + "sha256": "69369d0818d266e890c00e318f186fdb767b308ec0ffa12c8d498ad8ab8dafd4" + }, + "Lean.Data.PersistentArray": { + "relative_path": "lib/lean/Lean/Data/PersistentArray.olean", + "sha256": "14912531f574091502391030308b9fe1d9d6751b946af2614e19472c009ed084" + }, + "Lean.Data.PersistentHashMap": { + "relative_path": "lib/lean/Lean/Data/PersistentHashMap.olean", + "sha256": "1eb926bd3f03db27a647b1dd1ae1606722f7f8bd555a8c9e4197e00d69af8819" + }, + "Lean.Data.PersistentHashSet": { + "relative_path": "lib/lean/Lean/Data/PersistentHashSet.olean", + "sha256": "bbe6fe443d42b01b3ee7c45908dd2761f3e0996e47c6d05531bfd326b82a1927" + }, + "Lean.Data.Position": { + "relative_path": "lib/lean/Lean/Data/Position.olean", + "sha256": "1031cb2dd0a833b50284a503a02c8f71490d93182219e9b2e43c536370992719" + }, + "Lean.Data.PrefixTree": { + "relative_path": "lib/lean/Lean/Data/PrefixTree.olean", + "sha256": "1cfc295f1fee5de8bb9c641f6c6a67ed4d24b3cea24af1b44ce8baae361860d7" + }, + "Lean.Data.RArray": { + "relative_path": "lib/lean/Lean/Data/RArray.olean", + "sha256": "6846f637e7f46e1ed281043406f082980d0db3c56fd1fc34fd080be3e743b11a" + }, + "Lean.Data.RBMap": { + "relative_path": "lib/lean/Lean/Data/RBMap.olean", + "sha256": "ecdafd26877ccf099c7ad634090493a314130ddb1f511402e869f833179f677a" + }, + "Lean.Data.RBTree": { + "relative_path": "lib/lean/Lean/Data/RBTree.olean", + "sha256": "4a1139cda04f91a7a78086a92cbfa53af7cd5ed0b04f50f388e91caba39e72c4" + }, + "Lean.Data.SMap": { + "relative_path": "lib/lean/Lean/Data/SMap.olean", + "sha256": "1af0bd0e0119f17204517f5b0e3ae76e582ad139d167e04d4b872c3b80fb9446" + }, + "Lean.Data.SSet": { + "relative_path": "lib/lean/Lean/Data/SSet.olean", + "sha256": "3ce020534c8de2eaaf8b72fdc30dfeff283d9fdf9cb402ee7eaa9d6e06bed49a" + }, + "Lean.Data.Trie": { + "relative_path": "lib/lean/Lean/Data/Trie.olean", + "sha256": "425b99d0861d274a027650fd85e91fe2ea4c8d2b332c26f05ce3faa69f8b22a9" + }, + "Lean.Data.Xml": { + "relative_path": "lib/lean/Lean/Data/Xml.olean", + "sha256": "3051520fc1f5e8969c97cd69b2e390cc0291e716af0304ca910917ca40c395b6" + }, + "Lean.Data.Xml.Basic": { + "relative_path": "lib/lean/Lean/Data/Xml/Basic.olean", + "sha256": "b78909fa2d132e4733174d2ce5edb87022889a3c00034a5600c37366d1249798" + }, + "Lean.Data.Xml.Parser": { + "relative_path": "lib/lean/Lean/Data/Xml/Parser.olean", + "sha256": "ef6845551edad3dd21f97bc12796643808c3e736f98ea92cd3836de8d120f896" + }, + "Lean.Declaration": { + "relative_path": "lib/lean/Lean/Declaration.olean", + "sha256": "34e3ddb2ffb4c62a725faaa32d867b47ce0f0e88e4d05b88cb4b0e8d06afcf14" + }, + "Lean.DeclarationRange": { + "relative_path": "lib/lean/Lean/DeclarationRange.olean", + "sha256": "0acae02702629cf9d8d1914af744e4616b1a11ec0c36b87b061ddb544de6c77f" + }, + "Lean.DocString": { + "relative_path": "lib/lean/Lean/DocString.olean", + "sha256": "a3acd1c0a67f2041105b56e4358104b944cccadaf6282f51d2d6c92c588e1322" + }, + "Lean.DocString.Add": { + "relative_path": "lib/lean/Lean/DocString/Add.olean", + "sha256": "4e2edfbc5d94f30cb22899dd904adf4e886c31d74a14b4867d5e6990ae6bef1f" + }, + "Lean.DocString.Extension": { + "relative_path": "lib/lean/Lean/DocString/Extension.olean", + "sha256": "62da3e2b1a78c1564bc55d7a62a3dd0bf3a5bb680c78b064545b34f22ff5f594" + }, + "Lean.DocString.Links": { + "relative_path": "lib/lean/Lean/DocString/Links.olean", + "sha256": "cb06ad02ed13e3becad26e41c65955dc450c95efd3c03c7e243480eb441a280e" + }, + "Lean.Elab": { + "relative_path": "lib/lean/Lean/Elab.olean", + "sha256": "fb002575329248f441db46568924da0347c0fc94899a897d260ed87e8b060d3a" + }, + "Lean.Elab.App": { + "relative_path": "lib/lean/Lean/Elab/App.olean", + "sha256": "7f2ef3399ca2be27e53f782db9299d1262626709416ecbde404d3044360c20e2" + }, + "Lean.Elab.Arg": { + "relative_path": "lib/lean/Lean/Elab/Arg.olean", + "sha256": "43fcac69dfb8c829f70e5c25b51a6864a5926de26a7f59d59b3434c77d2a4b70" + }, + "Lean.Elab.Attributes": { + "relative_path": "lib/lean/Lean/Elab/Attributes.olean", + "sha256": "a5a66de9739bb05ccb5303622d7e370cb631c209bade735a5a9263a16f2e994e" + }, + "Lean.Elab.AutoBound": { + "relative_path": "lib/lean/Lean/Elab/AutoBound.olean", + "sha256": "bf849b5b3131ab0c7cd465721e2bff12b3007ab05787e45d9c45cfe31dbcd8d9" + }, + "Lean.Elab.AuxDef": { + "relative_path": "lib/lean/Lean/Elab/AuxDef.olean", + "sha256": "a48e7422c13ae3730a198f9535a2a4f1d52af7ddff79a8e3e44f17e382bded85" + }, + "Lean.Elab.BinderPredicates": { + "relative_path": "lib/lean/Lean/Elab/BinderPredicates.olean", + "sha256": "f19b46d5afb2ed4f25501c99c971d43ef80056b1b54537acfab9b844b4baa033" + }, + "Lean.Elab.Binders": { + "relative_path": "lib/lean/Lean/Elab/Binders.olean", + "sha256": "5382842df889f912fcdc6829b4da03bccb31d24f644c9dc267d549a049f1f6e2" + }, + "Lean.Elab.BindersUtil": { + "relative_path": "lib/lean/Lean/Elab/BindersUtil.olean", + "sha256": "dab5459f96c9af7151e019d42c16f735587fe9d2e465680af5542694045d024e" + }, + "Lean.Elab.BuiltinCommand": { + "relative_path": "lib/lean/Lean/Elab/BuiltinCommand.olean", + "sha256": "e8873e484147230a2d52ed220e5d991242e27b35cb3e04ac44a121b4e60674e6" + }, + "Lean.Elab.BuiltinEvalCommand": { + "relative_path": "lib/lean/Lean/Elab/BuiltinEvalCommand.olean", + "sha256": "c9ffac4f0e2a910c88b947565e7186e7496b2bb71a51d3efa8b57df1716e2721" + }, + "Lean.Elab.BuiltinNotation": { + "relative_path": "lib/lean/Lean/Elab/BuiltinNotation.olean", + "sha256": "a8854418983a3521ac0009f1d1bc5886cbee99a420b5853c955e2bba669c8a01" + }, + "Lean.Elab.BuiltinTerm": { + "relative_path": "lib/lean/Lean/Elab/BuiltinTerm.olean", + "sha256": "d1c759f9d638631d8c7fcc61d904c4b3022e467c85374536404b62bcae94dbfa" + }, + "Lean.Elab.Calc": { + "relative_path": "lib/lean/Lean/Elab/Calc.olean", + "sha256": "517858cf70dbd5a3567f8c7efa08ebb072924f0ab475d1ea392d2d71f404a067" + }, + "Lean.Elab.CheckTactic": { + "relative_path": "lib/lean/Lean/Elab/CheckTactic.olean", + "sha256": "4ee79b7594813f45a0be34f47d7dcb9040038d236c08d62d075bb533cd209a06" + }, + "Lean.Elab.Command": { + "relative_path": "lib/lean/Lean/Elab/Command.olean", + "sha256": "d70527ba43f3a254e944e0951c798896a50306d8eb16d8caf346cc2c8de2037e" + }, + "Lean.Elab.ComputedFields": { + "relative_path": "lib/lean/Lean/Elab/ComputedFields.olean", + "sha256": "8aa833985762117070e65be8efd47e1105136cb60c5dce5bd1c3d9b777829778" + }, + "Lean.Elab.Config": { + "relative_path": "lib/lean/Lean/Elab/Config.olean", + "sha256": "ab8b7261941780805d87f6cd63432afa539d6810b16b3728dfa0be2722c36bd4" + }, + "Lean.Elab.DeclModifiers": { + "relative_path": "lib/lean/Lean/Elab/DeclModifiers.olean", + "sha256": "082924ed9a1233708427a204ac06d00058e16efc75a4fbf2b05260bd4b4d23d9" + }, + "Lean.Elab.DeclNameGen": { + "relative_path": "lib/lean/Lean/Elab/DeclNameGen.olean", + "sha256": "3074bf25442d70036c97fadd21d83594e0b375d89a203068ccdcfbd5ac0778ab" + }, + "Lean.Elab.DeclUtil": { + "relative_path": "lib/lean/Lean/Elab/DeclUtil.olean", + "sha256": "60ed8c5034fdb91d96f0d29a947ae510e6aa2d2c8144c82d941b33d8a236cef2" + }, + "Lean.Elab.Declaration": { + "relative_path": "lib/lean/Lean/Elab/Declaration.olean", + "sha256": "60127f7068dd6080656cc0b8fc28c04e2297a8c22ed96c5ebc6a940bb746f3d6" + }, + "Lean.Elab.DeclarationRange": { + "relative_path": "lib/lean/Lean/Elab/DeclarationRange.olean", + "sha256": "4f693d72400c7b0083dc440da6cd99962551af0a31fcdc5f23ad218b4c1cf9ba" + }, + "Lean.Elab.DefView": { + "relative_path": "lib/lean/Lean/Elab/DefView.olean", + "sha256": "4b0690fe469dcc04235e5f1db28aca28c0a1d1890622e846894836d8465cbe27" + }, + "Lean.Elab.Deriving": { + "relative_path": "lib/lean/Lean/Elab/Deriving.olean", + "sha256": "ce2343744dcd7113446dba7686175adce1b219cfa3e2a02b883dc96c83ba7492" + }, + "Lean.Elab.Deriving.BEq": { + "relative_path": "lib/lean/Lean/Elab/Deriving/BEq.olean", + "sha256": "9ee4fb8b5a18bc9a71a2188781679f93e6f7084d7166d0abca3348a2ea069748" + }, + "Lean.Elab.Deriving.Basic": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Basic.olean", + "sha256": "1ce625bec288e07f709d51fce4479fa7c90fa26229a535dbf101fb15f094b1f4" + }, + "Lean.Elab.Deriving.DecEq": { + "relative_path": "lib/lean/Lean/Elab/Deriving/DecEq.olean", + "sha256": "02f7fe725e01d8646ab570659983869355626c34eba194247edcef78ec767253" + }, + "Lean.Elab.Deriving.FromToJson": { + "relative_path": "lib/lean/Lean/Elab/Deriving/FromToJson.olean", + "sha256": "02247476a022d1f65eedd2bd2edc694bd4dad5f4766c175b99613a7f7573c7a8" + }, + "Lean.Elab.Deriving.Hashable": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Hashable.olean", + "sha256": "d6a8f5480a4d92cad91e38425026a73585933acdea29983327c6847c2b262f88" + }, + "Lean.Elab.Deriving.Inhabited": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Inhabited.olean", + "sha256": "39f9db1e14cd9748ee9fa5d6a892f8aea231b94d854d6b18d8386ef424f71e2d" + }, + "Lean.Elab.Deriving.Nonempty": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Nonempty.olean", + "sha256": "99cf8010b9439d9586ec46c94e4667b1a779478c343adeddb8744e3e9a40b8f6" + }, + "Lean.Elab.Deriving.Ord": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Ord.olean", + "sha256": "4a047b2d5dfcd783ad4004184a3752bd8a7ab07dd8a694e097d1d935e2935e9e" + }, + "Lean.Elab.Deriving.Repr": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Repr.olean", + "sha256": "6b3f39ea3a48df4fcdc3f54f23443e518331051c09c139e251e24e08830be248" + }, + "Lean.Elab.Deriving.SizeOf": { + "relative_path": "lib/lean/Lean/Elab/Deriving/SizeOf.olean", + "sha256": "e92edf4220bbfd45b65b0fec728a4e4d4cd94681b03bba266afa98e2615b9723" + }, + "Lean.Elab.Deriving.ToExpr": { + "relative_path": "lib/lean/Lean/Elab/Deriving/ToExpr.olean", + "sha256": "d6523a528599743a7df654f5743b1528f21614d72a44f3abe2aa8a28d3bd648d" + }, + "Lean.Elab.Deriving.TypeName": { + "relative_path": "lib/lean/Lean/Elab/Deriving/TypeName.olean", + "sha256": "c4792fb38b5aeb5ea5a62636aff5f757d361aa8efd4f18c67004aae538a459b7" + }, + "Lean.Elab.Deriving.Util": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Util.olean", + "sha256": "c12884adaa0c778910c1bb93eaed6108bdaea5154acf789cfade6ed2d07bc557" + }, + "Lean.Elab.Do": { + "relative_path": "lib/lean/Lean/Elab/Do.olean", + "sha256": "f7edfae85cb0c26decf417da2b632bd988396e64b591ed1e83d80007039803f3" + }, + "Lean.Elab.ElabRules": { + "relative_path": "lib/lean/Lean/Elab/ElabRules.olean", + "sha256": "f9382a01adb96c2df46c91c3b8f089161a092e303fa6c21f6ee11e052b6ff4a2" + }, + "Lean.Elab.Eval": { + "relative_path": "lib/lean/Lean/Elab/Eval.olean", + "sha256": "7c71d21984db41ed525d830c97c499f6b6bb94896b3ef708a3f0f3c3992816be" + }, + "Lean.Elab.Exception": { + "relative_path": "lib/lean/Lean/Elab/Exception.olean", + "sha256": "c1966d832888ab689c6fb710ec26064030ce9114979ba2be5b55438d3a588875" + }, + "Lean.Elab.Extra": { + "relative_path": "lib/lean/Lean/Elab/Extra.olean", + "sha256": "e04aa742507f1f8ce71235aee3e0410a0349afcce02af8033eda84793fd3cb07" + }, + "Lean.Elab.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Frontend.olean", + "sha256": "8a78aa55e40dc042d0ef7ee6eb0ac9a8e32e69499d416edbeaf41a87389bdfcc" + }, + "Lean.Elab.GenInjective": { + "relative_path": "lib/lean/Lean/Elab/GenInjective.olean", + "sha256": "71e9b7c42d5c7ba361b678074beaa897c5d59561f84b92e61be9bce93ba1516c" + }, + "Lean.Elab.GuardMsgs": { + "relative_path": "lib/lean/Lean/Elab/GuardMsgs.olean", + "sha256": "c31104fae5363b5f9b40b457899730f0bf09cb532dbdba7019768a491bfbe033" + }, + "Lean.Elab.Import": { + "relative_path": "lib/lean/Lean/Elab/Import.olean", + "sha256": "942d562b54b0f9c16191c1dc631a63c61242e662bb6b20a96c21aca07febd4a2" + }, + "Lean.Elab.Inductive": { + "relative_path": "lib/lean/Lean/Elab/Inductive.olean", + "sha256": "c0773865c8c9ed8cf8dd1799819033f043b272ece64a17dcfca9c393fc65d4d1" + }, + "Lean.Elab.InfoTree": { + "relative_path": "lib/lean/Lean/Elab/InfoTree.olean", + "sha256": "e70760b7a719b09450ee47e653758f4b04bf770d2540ecdad9c68e1ff9dcffb1" + }, + "Lean.Elab.InfoTree.InlayHints": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/InlayHints.olean", + "sha256": "9ba09f4498147935a7cc795b4dbeb9c50d057cf40bd69dc080cabcb53c6f528a" + }, + "Lean.Elab.InfoTree.Main": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/Main.olean", + "sha256": "1d24d8fe2cf5c200615e2441353a8f2ccb183bd92272ad1a91c143f037e59159" + }, + "Lean.Elab.InfoTree.Types": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/Types.olean", + "sha256": "f5ef787b574b053eb6c4dedb63628dcab9c3323860e03b9f1689b919f5a43ea6" + }, + "Lean.Elab.InfoTrees": { + "relative_path": "lib/lean/Lean/Elab/InfoTrees.olean", + "sha256": "6d9c5aef462dd3f15682d204244f1f309fe21ef6ef10afb72805a052e7360f97" + }, + "Lean.Elab.InheritDoc": { + "relative_path": "lib/lean/Lean/Elab/InheritDoc.olean", + "sha256": "13baf3bf2e721fe666937e96ef2e4c05b29802168cdbd1dbcb5024ff90c12808" + }, + "Lean.Elab.LetRec": { + "relative_path": "lib/lean/Lean/Elab/LetRec.olean", + "sha256": "25dedf0d0c914e81ba7d5f40d8cac33b777717b8587e668add128fd532e0a129" + }, + "Lean.Elab.Level": { + "relative_path": "lib/lean/Lean/Elab/Level.olean", + "sha256": "6a2e73a7585f6edbc7aa991ced908c75f6a0b6677c602f9688c2187f4e424507" + }, + "Lean.Elab.Macro": { + "relative_path": "lib/lean/Lean/Elab/Macro.olean", + "sha256": "6d4ddaaad390cc33240dabfe92351ce1b4475bc00e2bfc13a1e7d1275b731e9c" + }, + "Lean.Elab.MacroArgUtil": { + "relative_path": "lib/lean/Lean/Elab/MacroArgUtil.olean", + "sha256": "66055bb8c852b726c6c019c0ea30d9680da2b79d0f7281bae9dd6aac4e69c745" + }, + "Lean.Elab.MacroRules": { + "relative_path": "lib/lean/Lean/Elab/MacroRules.olean", + "sha256": "87258a9723089efebfd06f4fd21de2d60819043181f411caf52db4e4d61c9269" + }, + "Lean.Elab.Match": { + "relative_path": "lib/lean/Lean/Elab/Match.olean", + "sha256": "f96ca7fa6ad4572f2e70f9caf0017d6b703f6343f966146652b6a4567e075ecb" + }, + "Lean.Elab.MatchAltView": { + "relative_path": "lib/lean/Lean/Elab/MatchAltView.olean", + "sha256": "bcc410a60ab916611cd1314ccb349d1e6291534e2f54f1acc879ae5dd92e127e" + }, + "Lean.Elab.MatchExpr": { + "relative_path": "lib/lean/Lean/Elab/MatchExpr.olean", + "sha256": "c4a41299da81eb484f5ed9c1f11a2ea202f408aedd6f89eec668ec2309a05668" + }, + "Lean.Elab.Mixfix": { + "relative_path": "lib/lean/Lean/Elab/Mixfix.olean", + "sha256": "9a948b85420661584f24c9c1adb6e9de9d89e53b1c9a71f91ebc0c27b7664c6b" + }, + "Lean.Elab.MutualDef": { + "relative_path": "lib/lean/Lean/Elab/MutualDef.olean", + "sha256": "1f9b71fb58473a9ed15668ce35710aadb27f433aa3d403cb989ae40f4f22c468" + }, + "Lean.Elab.MutualInductive": { + "relative_path": "lib/lean/Lean/Elab/MutualInductive.olean", + "sha256": "cadab2c90a0b83ef83df3405057155eceeb5335b3496f9f380677d08a5d03cf0" + }, + "Lean.Elab.Notation": { + "relative_path": "lib/lean/Lean/Elab/Notation.olean", + "sha256": "48412518cf3a658eae49c64cc1467c82b71bc9d8210744b25af28f2c920335ed" + }, + "Lean.Elab.Open": { + "relative_path": "lib/lean/Lean/Elab/Open.olean", + "sha256": "871d01b5e8a7d02623aae31186f1d6440de1e88cfa5a61aa65d49bc339b801b1" + }, + "Lean.Elab.ParseImportsFast": { + "relative_path": "lib/lean/Lean/Elab/ParseImportsFast.olean", + "sha256": "e7c263fcce8f9f845a93cbacd4270d29f526c6f49542bfd3fabda67b7bf6a78a" + }, + "Lean.Elab.PatternVar": { + "relative_path": "lib/lean/Lean/Elab/PatternVar.olean", + "sha256": "cc24f76e8a73bb74fa086ffc0ca15b83727e9fe862a2bebeb5ef951d328568ec" + }, + "Lean.Elab.PreDefinition": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition.olean", + "sha256": "cf08e93464411219890b4cb1bab8e1610a70a4fb65e43b50bd739539ef367547" + }, + "Lean.Elab.PreDefinition.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Basic.olean", + "sha256": "e37a918d0df8abd0297fe32ffe904d12705e71a5098c0c3299788bec711135d8" + }, + "Lean.Elab.PreDefinition.EqUnfold": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/EqUnfold.olean", + "sha256": "3461b20ecf2a82f12d463ada0c8741fa66ee5d67ad1f6baf6e744166ccecb007" + }, + "Lean.Elab.PreDefinition.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Eqns.olean", + "sha256": "19c4d86d1bc0cb30d41db8fee326500bff23ce73f35d422a577d118a346c3f4c" + }, + "Lean.Elab.PreDefinition.FixedParams": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/FixedParams.olean", + "sha256": "0b2ab92716760dec18c20cef92a923f45ced48471005b89968dc44cc042a7787" + }, + "Lean.Elab.PreDefinition.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Main.olean", + "sha256": "e9da272ef4937c5dea929555f1afb9c0bc5e546c46ba077dba6ecad53fc039f9" + }, + "Lean.Elab.PreDefinition.MkInhabitant": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/MkInhabitant.olean", + "sha256": "01386a0e9abb41906ebeff2b51300a35bdb976fd8f5414996e90edbe7aa71535" + }, + "Lean.Elab.PreDefinition.Mutual": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Mutual.olean", + "sha256": "7727402f03f91af4db7349660aa7d8ea7512be3c6a5a9745e4528df91b2d86e2" + }, + "Lean.Elab.PreDefinition.Nonrec.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.olean", + "sha256": "3651d817386974e312357f20f0f5b695df32636b45ad87bf257e12333522f7de" + }, + "Lean.Elab.PreDefinition.PartialFixpoint": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint.olean", + "sha256": "e66825e384ff17dc6519d4c3bbb1e2d437fb9d06ccd62c25ae39462160bb8a74" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.olean", + "sha256": "dfaf14ede280a406724d7388dfd50253eb1f72bc95053c73e5b5ec562eb13181" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Induction": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.olean", + "sha256": "ace8bf806b6e3c115ca8dca8903b2590944121d6ee15b166a9e90d26f8c65de2" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.olean", + "sha256": "ce6f69f8a60fbf4529c56fb9d180b9848c4dc94b0924669d52edadea1eea85da" + }, + "Lean.Elab.PreDefinition.Structural": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural.olean", + "sha256": "5df5e860a2941222d125302b6992dfee99076a8dfe7635e03d0067b1de52037b" + }, + "Lean.Elab.PreDefinition.Structural.BRecOn": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/BRecOn.olean", + "sha256": "43d778c2e31237bab4927df047f983f90d8e51f0c8994766eade48f3cf6ac721" + }, + "Lean.Elab.PreDefinition.Structural.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Basic.olean", + "sha256": "b9c232de8b46027f3e53de76dcd73a120fe39c3d59967a5a5d4b770687546ff6" + }, + "Lean.Elab.PreDefinition.Structural.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Eqns.olean", + "sha256": "1ab842d0ec3f072b7ef36c3c389106b6281772e9c39077183524e8a7b2df26d4" + }, + "Lean.Elab.PreDefinition.Structural.FindRecArg": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.olean", + "sha256": "22c836971360cfbae10b952afc57c8cceea7c6e0776bc4f5785db9f56231f4dc" + }, + "Lean.Elab.PreDefinition.Structural.IndGroupInfo": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.olean", + "sha256": "bcbc74eedc2f318a8b2b3f67dee27bbad4499edf1b90e1b5ef2f97392829471e" + }, + "Lean.Elab.PreDefinition.Structural.IndPred": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndPred.olean", + "sha256": "933c5f3adb300c234bc4b21c33ac88720ce348df0da6101f5e29e82e2c9ebd09" + }, + "Lean.Elab.PreDefinition.Structural.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Main.olean", + "sha256": "c4239a1efe6ae90a63a33c58a2a4416ad6811c5b137a4fff5e14dea0c97dbf4e" + }, + "Lean.Elab.PreDefinition.Structural.Preprocess": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Preprocess.olean", + "sha256": "da41c20561ffeedc9fa735b40812cfc6f2019cb4ae039fcc9b50bdb3c4b42beb" + }, + "Lean.Elab.PreDefinition.Structural.RecArgInfo": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.olean", + "sha256": "374c899afb685ea073722e49bbec2c586e1a3f301580147f1092dce75749f0e9" + }, + "Lean.Elab.PreDefinition.Structural.SmartUnfolding": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.olean", + "sha256": "a3bb8c3544d361c4654090f576b2f089aca1931220817eadc9e6fde12d8d2e84" + }, + "Lean.Elab.PreDefinition.TerminationHint": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/TerminationHint.olean", + "sha256": "b008cd03dae9e9eb39f7c961783c7688bb0079c86b3380e5a2acba0931c96912" + }, + "Lean.Elab.PreDefinition.TerminationMeasure": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/TerminationMeasure.olean", + "sha256": "7b6a83a24610cdb1a23a9e279cc4e2490f0984dc226172227a54b14653bc04b5" + }, + "Lean.Elab.PreDefinition.WF": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF.olean", + "sha256": "d756a42673113d104a8f1f10ec8e5266fd550ab3307d74635cff1a79dfdf50ee" + }, + "Lean.Elab.PreDefinition.WF.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Basic.olean", + "sha256": "30e303f01dd11f5bfb9bfe9f0ac7281cb267c79ee600883e9b75ec7ef3269c4a" + }, + "Lean.Elab.PreDefinition.WF.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Eqns.olean", + "sha256": "cbcee84f0b521613f3b81a830c4672dcec0ec776d61e47ac8e8a6b323e9d8dda" + }, + "Lean.Elab.PreDefinition.WF.Fix": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Fix.olean", + "sha256": "1cd3b02dd48b1739fbdd069bca0f18019590476d52d0b55f770483952212ed4c" + }, + "Lean.Elab.PreDefinition.WF.FloatRecApp": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.olean", + "sha256": "2b2b7508f7f5f71d39f30b406dc2b24879727bee44615b1eabe341e1df9438e1" + }, + "Lean.Elab.PreDefinition.WF.GuessLex": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/GuessLex.olean", + "sha256": "193a0f7bb3f60de6c3af28362ca4e34e9e5812f17dc23e55e448a949992f31df" + }, + "Lean.Elab.PreDefinition.WF.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Main.olean", + "sha256": "f877b579eeead916865fd609fde94addce79bb845e0d983e5733a88485a5766c" + }, + "Lean.Elab.PreDefinition.WF.PackMutual": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/PackMutual.olean", + "sha256": "2a5db58f9cf338b84db997411fc33bfe8e86284d92310df8c5de6e0b4319267f" + }, + "Lean.Elab.PreDefinition.WF.Preprocess": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Preprocess.olean", + "sha256": "1c2bd7a90e2254ed6d603023a49e6171f7c0d9a14b5516b28a4c216f5006fea9" + }, + "Lean.Elab.PreDefinition.WF.Rel": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Rel.olean", + "sha256": "c5bc9c3e5ac6b953c20efa66eb36629b6b957e1b043e34c4bc970e0c86aa0c11" + }, + "Lean.Elab.PreDefinition.WF.Unfold": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Unfold.olean", + "sha256": "e6f3e0b9a8ac077b6329df9ed9c09f78cd31e02841a3511420ee8e65d226bbe6" + }, + "Lean.Elab.Print": { + "relative_path": "lib/lean/Lean/Elab/Print.olean", + "sha256": "51e5f29b3d8074b0a7162eff78b664217a5dbc27efb76b145dbaea0c05c34a96" + }, + "Lean.Elab.Quotation": { + "relative_path": "lib/lean/Lean/Elab/Quotation.olean", + "sha256": "71b2f7b722ffcaeb09b2708d6bc5d6ff5cf1c17b12376699ea36d61f4b422eed" + }, + "Lean.Elab.Quotation.Precheck": { + "relative_path": "lib/lean/Lean/Elab/Quotation/Precheck.olean", + "sha256": "991a462e6701ed3ac0da579a5f9f2c7f7f666f3c9841eda19c86bb9576108653" + }, + "Lean.Elab.Quotation.Util": { + "relative_path": "lib/lean/Lean/Elab/Quotation/Util.olean", + "sha256": "f1eb03e06f604ef25245d13da5f6e5884e335fbb462b85cc25d2fddb1799a7fd" + }, + "Lean.Elab.RecAppSyntax": { + "relative_path": "lib/lean/Lean/Elab/RecAppSyntax.olean", + "sha256": "6abcf436c2719a2ec1d8bd634b141bc3276d0bf3e27e3cf005ea336fc9663bb7" + }, + "Lean.Elab.RecommendedSpelling": { + "relative_path": "lib/lean/Lean/Elab/RecommendedSpelling.olean", + "sha256": "9661fccfded1a3c1cfa6fd6ffb7d563b2884d98e4e644ab18eca9200cbebfab6" + }, + "Lean.Elab.SetOption": { + "relative_path": "lib/lean/Lean/Elab/SetOption.olean", + "sha256": "787c484587500ec3158e59ca10eebfea0af7d3083806a9471891821f6495a64d" + }, + "Lean.Elab.StructInst": { + "relative_path": "lib/lean/Lean/Elab/StructInst.olean", + "sha256": "47bb7c2c4610c8d54accb1bd6542626bb9d4b08e731135120c54cc9b9952abec" + }, + "Lean.Elab.Structure": { + "relative_path": "lib/lean/Lean/Elab/Structure.olean", + "sha256": "156b1283480708d45f2d4ccb21165c157b65fafa79490d678b5b221e6ee0b44e" + }, + "Lean.Elab.Syntax": { + "relative_path": "lib/lean/Lean/Elab/Syntax.olean", + "sha256": "6aad81137b009aa764c5d98639ee5fb600f0ce6fc27cdef1e073588a4c223986" + }, + "Lean.Elab.SyntheticMVars": { + "relative_path": "lib/lean/Lean/Elab/SyntheticMVars.olean", + "sha256": "765f17386784a6540f899b2af62be08e7b576a00a78f41584973b8fabf27d621" + }, + "Lean.Elab.Tactic": { + "relative_path": "lib/lean/Lean/Elab/Tactic.olean", + "sha256": "a8372c1c69001269930b6cbb4e881b9e8b593ac0d594e93ec7e6d361eaf3c368" + }, + "Lean.Elab.Tactic.AsAuxLemma": { + "relative_path": "lib/lean/Lean/Elab/Tactic/AsAuxLemma.olean", + "sha256": "3ab8861debb8b53d853057c0c66642079e60144679861402226630668939e906" + }, + "Lean.Elab.Tactic.BVDecide": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide.olean", + "sha256": "6736cf5da5943762151cf22c1342fc178f0f295bee9aeb7cf004c317aa45a07d" + }, + "Lean.Elab.Tactic.BVDecide.External": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/External.olean", + "sha256": "50fecaf48258db97412a2cafd593773db1dfa2339c681a31a4102f808b7a1327" + }, + "Lean.Elab.Tactic.BVDecide.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend.olean", + "sha256": "1336b674c40caf3ba24bb63e4b78ac58dee96d925c2fcc3036283109aaf823d0" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Attr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.olean", + "sha256": "7a316bf1617de928f47afdd80f6ca28befae2fe6ad6b96dac4b7e290360f579b" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVCheck": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.olean", + "sha256": "75b4d47160ec998fe08da4884247a1cea961fad7e19bf6357670f6f626d5f036" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.olean", + "sha256": "6557c91e5d2a05ba4a56c820828531dab370c1809771585e49a7b96a9a40ac75" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.olean", + "sha256": "2b22721a88841e65d1256e7d6b3a7132b26ff1197f1ca65e3be5a5eb21422d49" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.olean", + "sha256": "7f79411de643ca37c169708a76aa12321701070ad666f41c243b1c6df2f52e07" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.olean", + "sha256": "3fa0a32b34699ba1f97db7c29be8d8b88b47c47e52de12f6191d5e6327c613b4" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.olean", + "sha256": "a04f49452a90cab257db038fe0025d6e9b9f72ee3313a479b99fcac4ae1c8f13" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.olean", + "sha256": "6c4ff9969869b0ba86b098d8bb95e2caeb88bc61426a7659ec2d1e80fd3f0496" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.olean", + "sha256": "65491bfa39b0698c310a8a8878cb01596e4616627416f40ae45e0fd622709e54" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.olean", + "sha256": "980164e9c31b64c83e46c01e78ec64630226c39920485143be4e40b859da161e" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVTrace": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.olean", + "sha256": "1996eabaa1c3f4916f484b35c39a4bcc270e9a46b9592b9b6e63b28b95acd5fa" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.LRAT": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.olean", + "sha256": "a9777f4dc66bea0b57d7a9b2b750ce78d906d0bfa930cfd0b0281b5920467aba" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.olean", + "sha256": "74af1f202de4c2fbe0aeab11e5bf05bb495342404062a0db74097f35b666b423" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.olean", + "sha256": "b24d88b0fbed216dfdaf934f8653d37291af5e1288d5485736bfd75deb10c182" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.olean", + "sha256": "df98785c5e1b7e6e5114b0c1a90760ee11277742f3ec36f4834cafa51fc567a1" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.olean", + "sha256": "8abb3b652bdd68df142259c20a7e85e26fc1c7f1ad5d1111ad8574cb7251323f" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.olean", + "sha256": "07d568115382b9a9832437443a5665dd9ab05ebaaa6e613e2336083a18a5f843" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.olean", + "sha256": "5a338a9edef0294acf2e8ee6923e0b02965595576fff7b130ced1626af66fdc6" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.olean", + "sha256": "b999e4ddc8d0d2077c56af1f1a000fe53fa3e81c97b47c5bf48d4dfbc243cfd8" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.olean", + "sha256": "82d5b4e7c2ec35f28230ce0ea464680a38a439260496c2ecc624130c7177a14b" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.olean", + "sha256": "bf6a3b70f9fedd5c42111b2afd4a947fc8085947342a1123073f65558540f436" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.olean", + "sha256": "a6588498df687fb758121463de9ae1040535ceb6c317715218669e061b05a088" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.olean", + "sha256": "87a5d15e22301b1a7c50064a06e11cae3e2b3b7ae8f4db72437bd5dea8d09077" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.olean", + "sha256": "7e18d7f9c1daff3a8b7eeca9765a3933fb244156bb5a238b03fd3d6667146a57" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.olean", + "sha256": "a60b02e2a039134f7b533c911f7beed13d84812b6062b9f19185630e282912ce" + }, + "Lean.Elab.Tactic.BVDecide.LRAT": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT.olean", + "sha256": "2265489cbaad7404d01662160bc49c6036f770a8a23257ad912587b3c94c992f" + }, + "Lean.Elab.Tactic.BVDecide.LRAT.Trim": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.olean", + "sha256": "496f7c3dd081cece59390406bd9ca3d7b8280aa923e7d50e764867b0f3895546" + }, + "Lean.Elab.Tactic.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Basic.olean", + "sha256": "b7c0301d5608f70cc3b200a6c051173f74f9feffb83b1e7993b680a28e4dec4f" + }, + "Lean.Elab.Tactic.BoolToPropSimps": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BoolToPropSimps.olean", + "sha256": "d5e4ca3bfddbd7e2538e80f41161ea63be1ed1eec0bd637d064b11e4478c6737" + }, + "Lean.Elab.Tactic.BuiltinTactic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BuiltinTactic.olean", + "sha256": "72d1c873432fe4f9dff0aa9a83056dd824703fe0faa8593f5e2a186335e12c21" + }, + "Lean.Elab.Tactic.Calc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Calc.olean", + "sha256": "b22ed20091a768b533dbf3cb92b94e3dea2a22cc70e6e013bc0e932c0a92d721" + }, + "Lean.Elab.Tactic.Change": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Change.olean", + "sha256": "c3d3fe5640183577289c4f0c7dfc9a5e82953709dc9f81ab3305a64f2c972f83" + }, + "Lean.Elab.Tactic.Classical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Classical.olean", + "sha256": "dd96a577b5982c72e7c2f9cce5cf089a933ecc0614589fdd0d741b39c721b9d5" + }, + "Lean.Elab.Tactic.Config": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Config.olean", + "sha256": "18f6104d6c843452c5742a476d16659ee05d21021eefd2d72d3a9be27a4c0009" + }, + "Lean.Elab.Tactic.Congr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Congr.olean", + "sha256": "c2cbd01a116eeab3bc6d560d5b5e812915eda68ddd4fd972444df910e1ce6f07" + }, + "Lean.Elab.Tactic.Conv": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv.olean", + "sha256": "9e13c60aac36d8d5ab077fb214f9749bd03e689fd47b66fdeb65f54b42e61fcc" + }, + "Lean.Elab.Tactic.Conv.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Basic.olean", + "sha256": "36acbc413b0baecc6d1db794fdf6e9afdc393dbb0a43b4d132ed06e80af8987d" + }, + "Lean.Elab.Tactic.Conv.Change": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Change.olean", + "sha256": "d6645dd05e52922f9008332cc16dffd5e475221c524292446010a022f7180efc" + }, + "Lean.Elab.Tactic.Conv.Congr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Congr.olean", + "sha256": "b5c476623ea1b622800815da4f1d2b769643c1bdb0c4c7524bed4851276413bf" + }, + "Lean.Elab.Tactic.Conv.Delta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Delta.olean", + "sha256": "6953c32bc540eaaa79b2221b31a9eecf9d86fc5ce46e69cc8f0ad6a3f1902419" + }, + "Lean.Elab.Tactic.Conv.Pattern": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Pattern.olean", + "sha256": "8fae7911921a66098eba444b60030314b9f52f202353e586205472afdd07c068" + }, + "Lean.Elab.Tactic.Conv.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Rewrite.olean", + "sha256": "492425f642d76075007692216a7368c533ebb8e0def54334a7fbbe849baed77e" + }, + "Lean.Elab.Tactic.Conv.Simp": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Simp.olean", + "sha256": "914f50cab77467b8faa5d21c14664fa552ca6c69339ecfc798150b48b37d3272" + }, + "Lean.Elab.Tactic.Conv.Unfold": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Unfold.olean", + "sha256": "a893adf2f22bb0bae62f47d5c4b30ae3bcedc121a7ab747398e5f780262be63b" + }, + "Lean.Elab.Tactic.Delta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Delta.olean", + "sha256": "c80c125f4b2c716c5a140a18b02d0c2c2add3d4a4e749e9774b6e36a6e6d726f" + }, + "Lean.Elab.Tactic.DiscrTreeKey": { + "relative_path": "lib/lean/Lean/Elab/Tactic/DiscrTreeKey.olean", + "sha256": "90696c26393713d01d2efefc91713c23de2d2b9ea842dcd5b0be7602ef2d2d51" + }, + "Lean.Elab.Tactic.Doc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Doc.olean", + "sha256": "f7466ce696081046b90259ed10bfce6647f3e31b5b624987527aace912d6836d" + }, + "Lean.Elab.Tactic.ElabTerm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ElabTerm.olean", + "sha256": "c93025d17c141b6a8172abd80d25fd2083f061aea574ed5b5fb85752f32ef39f" + }, + "Lean.Elab.Tactic.ExposeNames": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ExposeNames.olean", + "sha256": "b5083e8a6aa77fd5d2aa2a73cdd0777e2f2e7018e6fe73f017e31220f136ab36" + }, + "Lean.Elab.Tactic.Ext": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Ext.olean", + "sha256": "41b7e7b7c44fec4c25d21754296cb2c63b901f6ec840e4d68fd5f73c0d27bf16" + }, + "Lean.Elab.Tactic.FalseOrByContra": { + "relative_path": "lib/lean/Lean/Elab/Tactic/FalseOrByContra.olean", + "sha256": "e9c4388c61790ea040377ad4794524db4078ac279c84bfda4873f93a9e286e72" + }, + "Lean.Elab.Tactic.Generalize": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Generalize.olean", + "sha256": "f508333fab3030de8fd72a5d3e269baab671664d61c9a4f9d838a86a49945533" + }, + "Lean.Elab.Tactic.Grind": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Grind.olean", + "sha256": "08be616fb5e448a7109ff7ea58dd14de1902dbe5e8df8a873ba79e4e34523c74" + }, + "Lean.Elab.Tactic.Guard": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Guard.olean", + "sha256": "f853574192c0c04c7a6fd40a04e71966bea87d164c2dfd58066119d2b273cc53" + }, + "Lean.Elab.Tactic.Induction": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Induction.olean", + "sha256": "cb71a7fa68a672ebb2f3bfa1643a418d82d0c545d5d5b2e992a46695a14f491e" + }, + "Lean.Elab.Tactic.Injection": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Injection.olean", + "sha256": "a21d54f553d5ecbeb0bb2983f5d37040186dca297ccaa8fe5457c15333f55662" + }, + "Lean.Elab.Tactic.LibrarySearch": { + "relative_path": "lib/lean/Lean/Elab/Tactic/LibrarySearch.olean", + "sha256": "aa4345322004c2831a322f51f0b28e6c846017c08fe3dc2861c6497dca393055" + }, + "Lean.Elab.Tactic.Location": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Location.olean", + "sha256": "1098b443df5ebadfee2fc68faf7038dabacb07541f38639ac31be344e1391bdf" + }, + "Lean.Elab.Tactic.Match": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Match.olean", + "sha256": "63335a98a881cb68e20bffdb30fa3771ecb62823849ae21bb31426adc5aaccc9" + }, + "Lean.Elab.Tactic.Meta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Meta.olean", + "sha256": "567713a64ca01f5b9ab6c091ed9cd25f3ae811dd96d379690824c1048238a466" + }, + "Lean.Elab.Tactic.Monotonicity": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Monotonicity.olean", + "sha256": "fa4e39f81c52c25684740ec8b522ddb1e75e2a770da086aa498542a0254bb3ab" + }, + "Lean.Elab.Tactic.NormCast": { + "relative_path": "lib/lean/Lean/Elab/Tactic/NormCast.olean", + "sha256": "8edb153050da1e5977675c29d0faa559f8ede051b8384ea592aa05c9c892e10d" + }, + "Lean.Elab.Tactic.Omega": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega.olean", + "sha256": "4b2613345cb64b57ac4f8a0183f43e1afe4138ef8eaed2158e9d053107262491" + }, + "Lean.Elab.Tactic.Omega.Core": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/Core.olean", + "sha256": "f133556a6f4675885619fb6fb25a670fb3afce9a98b14ab0b31d89b5ecb6a2ea" + }, + "Lean.Elab.Tactic.Omega.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/Frontend.olean", + "sha256": "03c91bedf7a6187e5e74519f66bda5d6e18552fa291f950f9d3310613d99013d" + }, + "Lean.Elab.Tactic.Omega.MinNatAbs": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/MinNatAbs.olean", + "sha256": "5fc208621322f361f7d3e75f63418aec5d8851c6b75bd6a39e922f0d8b0ba191" + }, + "Lean.Elab.Tactic.Omega.OmegaM": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/OmegaM.olean", + "sha256": "99de653d54903f4599f5883f5fc1fb078ca24550ff5656b10ff227552f8af2b8" + }, + "Lean.Elab.Tactic.RCases": { + "relative_path": "lib/lean/Lean/Elab/Tactic/RCases.olean", + "sha256": "cb15fe0c2bb64023666293bb14cd157c6d756fa59dc0e8aec39b8b6f28968731" + }, + "Lean.Elab.Tactic.Repeat": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Repeat.olean", + "sha256": "5f1389c2109470e537d2486218baea2f9b69842ad86150b3c78d919b589020b5" + }, + "Lean.Elab.Tactic.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rewrite.olean", + "sha256": "332ab3fca4f37076f27bbdf57e5d614923d0d1048e1e325c56a4ae5f78a3bdf0" + }, + "Lean.Elab.Tactic.Rewrites": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rewrites.olean", + "sha256": "510a661f998f5c279f14b60fec476368bb1ed9a003c3c4753c6caa2d88c349c1" + }, + "Lean.Elab.Tactic.Rfl": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rfl.olean", + "sha256": "debc83c10ccd0f91e6944c7f2409f0390766d3c90195d90b9bc3e379a5528ebf" + }, + "Lean.Elab.Tactic.ShowTerm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ShowTerm.olean", + "sha256": "1a58d3dab98f084c1e30cd1ad363f9dcce132dd3563f7f1b3a10ea4e5b982b31" + }, + "Lean.Elab.Tactic.Simp": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simp.olean", + "sha256": "7c99ed2d7fd716baaff7454c392df88cc0ed62c7717f7a3df5fde04e69b76a24" + }, + "Lean.Elab.Tactic.SimpArith": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SimpArith.olean", + "sha256": "947ba620a7f12f3039363f12e8b609b1532421e0a15de3091c7476f38200cd19" + }, + "Lean.Elab.Tactic.SimpTrace": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SimpTrace.olean", + "sha256": "71135cbb56c87c91b4654fc258dfee3c56abd5659705c75502c97bc4098f2b1b" + }, + "Lean.Elab.Tactic.Simpa": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simpa.olean", + "sha256": "ecf16470fb1388ccc43ef450a7cc9a3bea94c691d800f90b909817b14d277db2" + }, + "Lean.Elab.Tactic.Simproc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simproc.olean", + "sha256": "67adccf068a87d29a3658b600ea8d395ad93eb34518f94930e273e9dd227a998" + }, + "Lean.Elab.Tactic.SolveByElim": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SolveByElim.olean", + "sha256": "4b83ef14834e716e40e4225b7fc6e6e0be6a4fac044490fcdcea8684314e9890" + }, + "Lean.Elab.Tactic.Split": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Split.olean", + "sha256": "1d662891823face6895782eadc704cb76813e37325f70c681ac2e481219d06a2" + }, + "Lean.Elab.Tactic.Symm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Symm.olean", + "sha256": "03415c9848515aa79dac3634eda5a005dbe2d662168206bdae2d4aeebbc5c670" + }, + "Lean.Elab.Tactic.TreeTacAttr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/TreeTacAttr.olean", + "sha256": "317645bd9832a71c3d83747c516f0084c6f778a2f01a9f1725396a9ee99f9405" + }, + "Lean.Elab.Tactic.Try": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Try.olean", + "sha256": "e06377c171ef6f8d33196b70e2c138672956f14a668924bd8dbba6ede2325966" + }, + "Lean.Elab.Tactic.Unfold": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Unfold.olean", + "sha256": "a096a399bfc253d22fceda76ad31bfe1c32923302d3fc517e0736b8c2e29fb74" + }, + "Lean.Elab.Term": { + "relative_path": "lib/lean/Lean/Elab/Term.olean", + "sha256": "f96c6c457c651da44cb9aed7d0af002589a9dd635ec492029254eeb679e85703" + }, + "Lean.Elab.Time": { + "relative_path": "lib/lean/Lean/Elab/Time.olean", + "sha256": "6b9da11286e522cb54d1759a5e4f93f50dc49b537c785daca8362c216c0141ef" + }, + "Lean.Elab.Util": { + "relative_path": "lib/lean/Lean/Elab/Util.olean", + "sha256": "d17dd23eb1ff8167dfe81c18ca2d79eb2aa863ad660be8f91057f952ac60ec2e" + }, + "Lean.Environment": { + "relative_path": "lib/lean/Lean/Environment.olean", + "sha256": "f65e86963b340104aec0500759c0221ce805877552a74a222444517efea4f327" + }, + "Lean.Exception": { + "relative_path": "lib/lean/Lean/Exception.olean", + "sha256": "348180c98395bf5936594ac1a00295baf447f096c9d55de58f1ad28b80ff532e" + }, + "Lean.Expr": { + "relative_path": "lib/lean/Lean/Expr.olean", + "sha256": "b109611aabeef2b002d78f15e7d05934c7af1dc5739a2aadde294f1417e828ee" + }, + "Lean.HeadIndex": { + "relative_path": "lib/lean/Lean/HeadIndex.olean", + "sha256": "a184c76eed310d6d6e6a855f50d25e694c10a0f3be2c8c2e01aafa23113aa817" + }, + "Lean.Hygiene": { + "relative_path": "lib/lean/Lean/Hygiene.olean", + "sha256": "f8122bf1f713f1514bdbdeb3cee8090c7d524255998bdb3f077a26fbf9e33bb9" + }, + "Lean.ImportingFlag": { + "relative_path": "lib/lean/Lean/ImportingFlag.olean", + "sha256": "ce6df3c54e60e9f9741b44b6c787667ff8edea324d61df14d97c3c6be2d4a314" + }, + "Lean.InternalExceptionId": { + "relative_path": "lib/lean/Lean/InternalExceptionId.olean", + "sha256": "314fb4e2c9c8a74700fb4ba28ff8996102d6960b101dc5e8ea058928b76671e7" + }, + "Lean.KeyedDeclsAttribute": { + "relative_path": "lib/lean/Lean/KeyedDeclsAttribute.olean", + "sha256": "6965a89059d292ffd11ede6d477a9895b5742df767da760a63958167e08709da" + }, + "Lean.LabelAttribute": { + "relative_path": "lib/lean/Lean/LabelAttribute.olean", + "sha256": "f6357ee28525c80e0e1e50f30d6abc8e9c212faf66266638907f7734baf8c4a9" + }, + "Lean.Language.Basic": { + "relative_path": "lib/lean/Lean/Language/Basic.olean", + "sha256": "116198598d0a090a3f8c1ac2df76863e2c130506768f741dd96c657b4f28f62c" + }, + "Lean.Language.Lean": { + "relative_path": "lib/lean/Lean/Language/Lean.olean", + "sha256": "ec21c3356101da99d833c4dbe27da14a587b238e0dcfead17dd1954358b4e730" + }, + "Lean.Language.Lean.Types": { + "relative_path": "lib/lean/Lean/Language/Lean/Types.olean", + "sha256": "e41961572ed5c15c53ca9829747714c5157397631bd11805558205cc21d2c300" + }, + "Lean.Language.Util": { + "relative_path": "lib/lean/Lean/Language/Util.olean", + "sha256": "7a02b960729bb110fe366fa1cfc75e7974ed6c4e984488b3d41c3701bae6d021" + }, + "Lean.Level": { + "relative_path": "lib/lean/Lean/Level.olean", + "sha256": "b0a2bdff71bacb1202f1c2b034fbfcaef3a928cb8508fe31751111872644168f" + }, + "Lean.Linter": { + "relative_path": "lib/lean/Lean/Linter.olean", + "sha256": "0ad71e4ddd414f842de88817808764b12d0dbc35fb0250beb219a6aac4d105e1" + }, + "Lean.Linter.Basic": { + "relative_path": "lib/lean/Lean/Linter/Basic.olean", + "sha256": "f15c89429080e69fa9ce443c7ab1462990d6cfb127c38ce3cc2e9c3150eaf319" + }, + "Lean.Linter.Builtin": { + "relative_path": "lib/lean/Lean/Linter/Builtin.olean", + "sha256": "65bcaf73e26b3b782cc55118edee888ef878f6eb321ef6c89ba6344c8c828727" + }, + "Lean.Linter.ConstructorAsVariable": { + "relative_path": "lib/lean/Lean/Linter/ConstructorAsVariable.olean", + "sha256": "d23b80487fc0b4ffb80cfe74517b2b44c317f857288c45e9573fa5595e7c0b76" + }, + "Lean.Linter.Deprecated": { + "relative_path": "lib/lean/Lean/Linter/Deprecated.olean", + "sha256": "ee83025c6435587e7822db2d39a94f7192a3be4828e76712936a6d687c1654b5" + }, + "Lean.Linter.List": { + "relative_path": "lib/lean/Lean/Linter/List.olean", + "sha256": "72b11db674930f01297e66d6fe9168b2711db7ed0f3a8062014bbe5628431447" + }, + "Lean.Linter.MissingDocs": { + "relative_path": "lib/lean/Lean/Linter/MissingDocs.olean", + "sha256": "89abae84ca6318a0f514ad6ab9164a28db6a35afe87b77303fca87d4a725dcff" + }, + "Lean.Linter.Omit": { + "relative_path": "lib/lean/Lean/Linter/Omit.olean", + "sha256": "8e0d622b1be4f992d2355f4ec978f33899e36c6caaeca50b3394326f74cab35e" + }, + "Lean.Linter.UnusedVariables": { + "relative_path": "lib/lean/Lean/Linter/UnusedVariables.olean", + "sha256": "d5bae599fc34fe808ea8d61cefa05405ae98d97184c208c92cbe883e9dfc20ea" + }, + "Lean.Linter.Util": { + "relative_path": "lib/lean/Lean/Linter/Util.olean", + "sha256": "e983ec22a68494993b52d4bc349e4fd8ed0e73c11a7236cdcfd14c58058da4a3" + }, + "Lean.LoadDynlib": { + "relative_path": "lib/lean/Lean/LoadDynlib.olean", + "sha256": "7bbb1aa363e257a2de2975ac17e31bbf58d4d4cd328d592710e6a718e71496b4" + }, + "Lean.LocalContext": { + "relative_path": "lib/lean/Lean/LocalContext.olean", + "sha256": "1b6191a3341ed46fa6b8dbcd3f24e245ae1b8c6ab39d080f2ff5cecc2e26250e" + }, + "Lean.Log": { + "relative_path": "lib/lean/Lean/Log.olean", + "sha256": "032fbe05a131072d1b0779947f012b10687e42ee07019d7ea29fff2d100e709f" + }, + "Lean.Message": { + "relative_path": "lib/lean/Lean/Message.olean", + "sha256": "c36f1a3906e9d18d564572f38bd3b687db02b21897db07f6470025ae522ea73f" + }, + "Lean.Meta": { + "relative_path": "lib/lean/Lean/Meta.olean", + "sha256": "206cf2fcc5bef1191f930198dfb2b0cd2042bf96f47c40faaf98cc105e137809" + }, + "Lean.Meta.ACLt": { + "relative_path": "lib/lean/Lean/Meta/ACLt.olean", + "sha256": "da1c2e3e8f486413a1fee34f34a938179cfdd72342ced421b82d230af508788d" + }, + "Lean.Meta.AbstractMVars": { + "relative_path": "lib/lean/Lean/Meta/AbstractMVars.olean", + "sha256": "a3e0a762ba6c0f8852c50c993c98208b5ce37e53cd374530f2b6f2cd119a4b34" + }, + "Lean.Meta.AbstractNestedProofs": { + "relative_path": "lib/lean/Lean/Meta/AbstractNestedProofs.olean", + "sha256": "fc0a2ed4ddd5bfc2c16958b017a88d2751126cec190d0eeb80a777c6825d2fa4" + }, + "Lean.Meta.AppBuilder": { + "relative_path": "lib/lean/Lean/Meta/AppBuilder.olean", + "sha256": "7cd2bf696029e7211829c3c8152df760b2e4695304ca409a76775c196ae56549" + }, + "Lean.Meta.ArgsPacker": { + "relative_path": "lib/lean/Lean/Meta/ArgsPacker.olean", + "sha256": "a7f9e66a5cc17f1ce38ec0b459f0ca4ab7b8a4273762e2c05b35ad57626b539e" + }, + "Lean.Meta.ArgsPacker.Basic": { + "relative_path": "lib/lean/Lean/Meta/ArgsPacker/Basic.olean", + "sha256": "6d74b8180f4fbc25df85bd09ae4ff159591fd5b7ec68dc02b798cb70a79112e4" + }, + "Lean.Meta.Basic": { + "relative_path": "lib/lean/Lean/Meta/Basic.olean", + "sha256": "f12db9629e0a571e3774816fec958dbc481f79f7b8a2c4c4bbd5208e12ccc24d" + }, + "Lean.Meta.BinderNameHint": { + "relative_path": "lib/lean/Lean/Meta/BinderNameHint.olean", + "sha256": "0d948af6513e8326ed601ea521ff00b87dd6d019bd5b60bf40860a7e5f5905f8" + }, + "Lean.Meta.Canonicalizer": { + "relative_path": "lib/lean/Lean/Meta/Canonicalizer.olean", + "sha256": "9262985c3ac4e2f8b7207fdeb2bf7fbab1db0dc6581b85a26c2cc27965ec43ee" + }, + "Lean.Meta.Check": { + "relative_path": "lib/lean/Lean/Meta/Check.olean", + "sha256": "502569420ced0ae9c7c72746fe0a34b7340279a7852e922a9b8ec5c183b97235" + }, + "Lean.Meta.CheckTactic": { + "relative_path": "lib/lean/Lean/Meta/CheckTactic.olean", + "sha256": "30e7beace22600567ab8f275bda3c48c83d8d80a14a654a0f723e125eef28377" + }, + "Lean.Meta.Closure": { + "relative_path": "lib/lean/Lean/Meta/Closure.olean", + "sha256": "092e59d5c44691e648c7e6b4151d18030b17a703b124d134c3e233d952c90058" + }, + "Lean.Meta.Coe": { + "relative_path": "lib/lean/Lean/Meta/Coe.olean", + "sha256": "72cd74ba7424353c0c7acb6cd05dd27d7f27d07fa8936fd54a96141d22d7671c" + }, + "Lean.Meta.CoeAttr": { + "relative_path": "lib/lean/Lean/Meta/CoeAttr.olean", + "sha256": "16993537a5507a03ac41462d5a54030993c6e9303353d59270b5df4762af31a9" + }, + "Lean.Meta.CollectFVars": { + "relative_path": "lib/lean/Lean/Meta/CollectFVars.olean", + "sha256": "d46e2325951ddff2997f5d37f9b688edc09d75d360711d9ae51415b9ed6a6dde" + }, + "Lean.Meta.CollectMVars": { + "relative_path": "lib/lean/Lean/Meta/CollectMVars.olean", + "sha256": "b2846166247972427c1225d20859aaa46fe676c321f3e4b8943ae064d9259b1e" + }, + "Lean.Meta.CompletionName": { + "relative_path": "lib/lean/Lean/Meta/CompletionName.olean", + "sha256": "2af094a0fd892457002a8b311a318ebb1d3b347f694fa5bd3c4a710bb3d0f5ae" + }, + "Lean.Meta.CongrTheorems": { + "relative_path": "lib/lean/Lean/Meta/CongrTheorems.olean", + "sha256": "ae1d73989795378f2db8d6725484544fbf700d26861669e26ed071fb3d5aa774" + }, + "Lean.Meta.Constructions": { + "relative_path": "lib/lean/Lean/Meta/Constructions.olean", + "sha256": "bd42abcf4b09dd47d7b07f34bce755794a76f242171f34720060f743c91d7e7b" + }, + "Lean.Meta.Constructions.BRecOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/BRecOn.olean", + "sha256": "91bb12647e28558fa3562e3ef84df4f40044d7a68fa2d0a0092f9a8b52852111" + }, + "Lean.Meta.Constructions.CasesOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/CasesOn.olean", + "sha256": "827e45d478f86cf087cc904ee3c3021343ac62fcf500ced79f733a631a72c4c8" + }, + "Lean.Meta.Constructions.NoConfusion": { + "relative_path": "lib/lean/Lean/Meta/Constructions/NoConfusion.olean", + "sha256": "4428b1ecf05f66c20cbfd068963aa5778bb1dc417f84e24a99010e93618d9268" + }, + "Lean.Meta.Constructions.RecOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/RecOn.olean", + "sha256": "08d7bf9cce44bfb9da0382e248b7232936f8e9b4e04d9f01272257e2c3e93e58" + }, + "Lean.Meta.CtorRecognizer": { + "relative_path": "lib/lean/Lean/Meta/CtorRecognizer.olean", + "sha256": "dc104bc4378dcd0427c4d67654ad199261907c9434bd5e59548f1960b7918c57" + }, + "Lean.Meta.DecLevel": { + "relative_path": "lib/lean/Lean/Meta/DecLevel.olean", + "sha256": "a2eed500e45408ea6f1531256849e4e47d7cb3ccdb8621c3a44769f45d23d37a" + }, + "Lean.Meta.Diagnostics": { + "relative_path": "lib/lean/Lean/Meta/Diagnostics.olean", + "sha256": "e64e866f33cb55305ffb4588647652a034aa08108bda8e49ba7b87f5b5c09dc8" + }, + "Lean.Meta.DiscrTree": { + "relative_path": "lib/lean/Lean/Meta/DiscrTree.olean", + "sha256": "a285696f66951a789b2d325baec39c256f247a40c4c442dcc5b5c631185a590e" + }, + "Lean.Meta.DiscrTreeTypes": { + "relative_path": "lib/lean/Lean/Meta/DiscrTreeTypes.olean", + "sha256": "35157be01b47d45c6ccfb978fe042752d42b919a13c2c59df749d78df28513d1" + }, + "Lean.Meta.Eqns": { + "relative_path": "lib/lean/Lean/Meta/Eqns.olean", + "sha256": "61d27ab1c2d1ea8db95324a4612e717c5e0a8c9fd7e6bb7cb13c928f4cc63703" + }, + "Lean.Meta.Eval": { + "relative_path": "lib/lean/Lean/Meta/Eval.olean", + "sha256": "8451e897121ce84e0e443be0ad1de1177143a1960c634d31c1b373d0ec30e5a1" + }, + "Lean.Meta.ExprDefEq": { + "relative_path": "lib/lean/Lean/Meta/ExprDefEq.olean", + "sha256": "ac84eb17f56223f5cf46553327dbfa0279b437802957cb292551c592b449a502" + }, + "Lean.Meta.ExprLens": { + "relative_path": "lib/lean/Lean/Meta/ExprLens.olean", + "sha256": "b8ac1969551532255d7a2b0223a00c65bf0bc468f90e7aba64fd6c697db6bb5b" + }, + "Lean.Meta.ExprTraverse": { + "relative_path": "lib/lean/Lean/Meta/ExprTraverse.olean", + "sha256": "b0cf3399e8837d8019f29b7e42b94028b42c6fcf40bca98a498ee9a3641ff948" + }, + "Lean.Meta.ForEachExpr": { + "relative_path": "lib/lean/Lean/Meta/ForEachExpr.olean", + "sha256": "6f2ade443619ee7d60f73bc62b4e1efd7372418d4f5b28b8b8233ac2c28ce1a9" + }, + "Lean.Meta.FunInfo": { + "relative_path": "lib/lean/Lean/Meta/FunInfo.olean", + "sha256": "b855ba9c1d30fec86c39339dd3cbfef0cfcdcdb7e78c25ad04103b37abc1a9ca" + }, + "Lean.Meta.GeneralizeTelescope": { + "relative_path": "lib/lean/Lean/Meta/GeneralizeTelescope.olean", + "sha256": "5ee0c1c92441c434c043593778ed21e47badeadce84e78a99682cedfad480372" + }, + "Lean.Meta.GeneralizeVars": { + "relative_path": "lib/lean/Lean/Meta/GeneralizeVars.olean", + "sha256": "796bc3bc0a297f547b39413e39611eb8829e642e7f44da2f4cea6d0d4ef56265" + }, + "Lean.Meta.GetUnfoldableConst": { + "relative_path": "lib/lean/Lean/Meta/GetUnfoldableConst.olean", + "sha256": "2ea066ddcc64d26c2d70e77bd3c7b015c8ee3f755d10187352eb155962d91427" + }, + "Lean.Meta.GlobalInstances": { + "relative_path": "lib/lean/Lean/Meta/GlobalInstances.olean", + "sha256": "8265fb3b50c621767dc77e38921e2fe7360694ce5b7ac3e24bdc67e0c3946f57" + }, + "Lean.Meta.IndPredBelow": { + "relative_path": "lib/lean/Lean/Meta/IndPredBelow.olean", + "sha256": "c93d1f840670b555e569ac9d262d1f41decd51f3d134d54ff4e53bb542e9cb58" + }, + "Lean.Meta.Inductive": { + "relative_path": "lib/lean/Lean/Meta/Inductive.olean", + "sha256": "cbd800e5e3644765969dc14c322b700120c9dd2c3db0d499e72c13f607fb29aa" + }, + "Lean.Meta.InferType": { + "relative_path": "lib/lean/Lean/Meta/InferType.olean", + "sha256": "a9e3c61dd6022e6864ca3416c5567360975a3781076d8dedd4b93507bfe12703" + }, + "Lean.Meta.Injective": { + "relative_path": "lib/lean/Lean/Meta/Injective.olean", + "sha256": "022f6530d2761e0fd32e4a8a1d390badfe3bbf852a92bebf2269b4cacf93ac9d" + }, + "Lean.Meta.Instances": { + "relative_path": "lib/lean/Lean/Meta/Instances.olean", + "sha256": "fcc360ddf8ee95db9d62118b0c262c6695b38251dcd96f086fee6c5195966516" + }, + "Lean.Meta.IntInstTesters": { + "relative_path": "lib/lean/Lean/Meta/IntInstTesters.olean", + "sha256": "33498b0c4626bd28ce45b7a3f7996aaee28f3cea1e8a9a6cbbe6fdeb24619209" + }, + "Lean.Meta.Iterator": { + "relative_path": "lib/lean/Lean/Meta/Iterator.olean", + "sha256": "101d4d68efea3a23fbd0dc5f16e63ff16c65b391862a09feee2f7930dc671703" + }, + "Lean.Meta.KAbstract": { + "relative_path": "lib/lean/Lean/Meta/KAbstract.olean", + "sha256": "1ff48dc21dc7daa5701ec93ebf8dea8e853eb9c76c7f08df3c047b2e364c0fd6" + }, + "Lean.Meta.KExprMap": { + "relative_path": "lib/lean/Lean/Meta/KExprMap.olean", + "sha256": "a61c80321e32eb1ac29c70f05a557bc9a950b6a65d0503e94031cd21c697f84c" + }, + "Lean.Meta.LazyDiscrTree": { + "relative_path": "lib/lean/Lean/Meta/LazyDiscrTree.olean", + "sha256": "0e52ab3e1bba285513237aa0ad00ebbeca9f6f2de5e6ffed01aa0aff4ebce915" + }, + "Lean.Meta.LevelDefEq": { + "relative_path": "lib/lean/Lean/Meta/LevelDefEq.olean", + "sha256": "039d6b9b7f252227092b329102542df7d9c09edceb1aefa45fc712078c65c5d7" + }, + "Lean.Meta.LitValues": { + "relative_path": "lib/lean/Lean/Meta/LitValues.olean", + "sha256": "fc41c863bde3e203433870eb601640349cb7855f816bdebbde1a2a204c9bdace" + }, + "Lean.Meta.Match": { + "relative_path": "lib/lean/Lean/Meta/Match.olean", + "sha256": "548ceb8925264b3c53204550bfea3548b9e73b11f0124d9a7f4343aed053ad9d" + }, + "Lean.Meta.Match.Basic": { + "relative_path": "lib/lean/Lean/Meta/Match/Basic.olean", + "sha256": "ad8f2a68e4366a7c0c5939323446515ac428595f1da113a506bf12039fb16442" + }, + "Lean.Meta.Match.CaseArraySizes": { + "relative_path": "lib/lean/Lean/Meta/Match/CaseArraySizes.olean", + "sha256": "e221018a693db011a0414635b7b68c8b8388950b2c2d4731ce41a6a5576a1d57" + }, + "Lean.Meta.Match.CaseValues": { + "relative_path": "lib/lean/Lean/Meta/Match/CaseValues.olean", + "sha256": "537ddad23a87967f7088967a2a347eb108cc36e2d4e4d9ffb0a8396d65da88df" + }, + "Lean.Meta.Match.Match": { + "relative_path": "lib/lean/Lean/Meta/Match/Match.olean", + "sha256": "2e73790b9ba9e908afaec1f9636dbe6f8ca5388dd11caa89f03e0e9579138516" + }, + "Lean.Meta.Match.MatchEqs": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchEqs.olean", + "sha256": "3e0c930d82985234eaf74ec74fb3bc7dffc959608f43bd38ac33a884500315a7" + }, + "Lean.Meta.Match.MatchEqsExt": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchEqsExt.olean", + "sha256": "bfe53903e9962eeede9b619f0ba796108662c4945af59198a5834799589b1d68" + }, + "Lean.Meta.Match.MatchPatternAttr": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchPatternAttr.olean", + "sha256": "6c7c6f96c64e483fc2864cb94a9e2f1fe2570e04660100eec221bb0511e5684a" + }, + "Lean.Meta.Match.MatcherApp": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp.olean", + "sha256": "e2ed9a86cbc2817d5fa9a023ef571b6b077e2626b8c4e6799fc4f9c31bfa9520" + }, + "Lean.Meta.Match.MatcherApp.Basic": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp/Basic.olean", + "sha256": "cd872e793052ffcbbdaed58e949e35afe056e7b7177b49c70d3c5fd6cb269825" + }, + "Lean.Meta.Match.MatcherApp.Transform": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp/Transform.olean", + "sha256": "df0e6ddff62c7c9906a8704ed1338b841299acbdb0c4894eea4dd9f253824cb4" + }, + "Lean.Meta.Match.MatcherInfo": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherInfo.olean", + "sha256": "83151f202d8e0d8b58fd86326458d33e3f8f060038aaccc7909d07cfb8c4a5c6" + }, + "Lean.Meta.Match.Value": { + "relative_path": "lib/lean/Lean/Meta/Match/Value.olean", + "sha256": "0c40eecc0e0da4ec9cc2eec21580f3493911fb56c753dab89c51327bfb64551a" + }, + "Lean.Meta.MatchUtil": { + "relative_path": "lib/lean/Lean/Meta/MatchUtil.olean", + "sha256": "5ff0623e662f1b1ba9035709de58345cf18417f05bf3580448d963471d4f1f93" + }, + "Lean.Meta.NatInstTesters": { + "relative_path": "lib/lean/Lean/Meta/NatInstTesters.olean", + "sha256": "3a54ef6c555c2304cd894a59b7519e7cf1138c5082ea7c6b541d2558f68d729e" + }, + "Lean.Meta.Offset": { + "relative_path": "lib/lean/Lean/Meta/Offset.olean", + "sha256": "e9bccfe44f2cb64ac53bdb8d4391720754a15706c982a7f4ee8b3c19b2001ed2" + }, + "Lean.Meta.PPGoal": { + "relative_path": "lib/lean/Lean/Meta/PPGoal.olean", + "sha256": "1ff4e4b1dd870a3fc09b5b9bd5bdf20dd4a0263d2a652b4d4d3461495e7d713b" + }, + "Lean.Meta.PProdN": { + "relative_path": "lib/lean/Lean/Meta/PProdN.olean", + "sha256": "d8b86b781fa66571ceb5087c16cac87cd37beb344e9134818bff6e4003f2a6b4" + }, + "Lean.Meta.RecursorInfo": { + "relative_path": "lib/lean/Lean/Meta/RecursorInfo.olean", + "sha256": "c7deca642d62ab08712aa143b716f781872a5e421470246d94bc9fb7dd862b47" + }, + "Lean.Meta.Reduce": { + "relative_path": "lib/lean/Lean/Meta/Reduce.olean", + "sha256": "6ae0326d4d14d180af14176daf097cf236bd4347a95d87b93a7e5996d1ae95ea" + }, + "Lean.Meta.ReduceEval": { + "relative_path": "lib/lean/Lean/Meta/ReduceEval.olean", + "sha256": "50aaeb5ac37fb6154b0e2c1c5d3085f3cf61736ec3b316ab2bd9e7d4d7babc40" + }, + "Lean.Meta.SizeOf": { + "relative_path": "lib/lean/Lean/Meta/SizeOf.olean", + "sha256": "af408b51fc723ab8bd677b7e5a84d33b6639d1e481b7f058d3e5f16200c7a5c5" + }, + "Lean.Meta.Sorry": { + "relative_path": "lib/lean/Lean/Meta/Sorry.olean", + "sha256": "56b4c84f52c8c7925b6c1a850fb91ff7d7966e113ed79a39e140ae46f5fde7a9" + }, + "Lean.Meta.Structure": { + "relative_path": "lib/lean/Lean/Meta/Structure.olean", + "sha256": "e5f9fa309279c95a5cf27878c316b302eba85e26b4aa1d6e85f5b43d6453616a" + }, + "Lean.Meta.SynthInstance": { + "relative_path": "lib/lean/Lean/Meta/SynthInstance.olean", + "sha256": "dc0a3b8ea0ef34849ba5ca57477fd5ccb37d7ccad92151d8b231f17afb86c5dd" + }, + "Lean.Meta.Tactic": { + "relative_path": "lib/lean/Lean/Meta/Tactic.olean", + "sha256": "ad4914ed10cf80c2d4a2388d6fb8af91cc2d2991c9475e8cab2eb6ba7d57ea22" + }, + "Lean.Meta.Tactic.AC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AC.olean", + "sha256": "ee57ccf20ad198b447ea1b6e0f7ceb4a6b3ae399b5dc45ca144164e7f41148fc" + }, + "Lean.Meta.Tactic.AC.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AC/Main.olean", + "sha256": "2bdbf30c5961d39ed784e11ba8bbbee10f34d882c8e515bfedfaae65c2983174" + }, + "Lean.Meta.Tactic.Acyclic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Acyclic.olean", + "sha256": "1d138ed59a13cdb5360dee24852ee3dcef4d97a3da34e175c3d5ba1a5afbfe98" + }, + "Lean.Meta.Tactic.Apply": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Apply.olean", + "sha256": "c1283b20feace19b65fc7e23af16221b8d0a14ac59dd7c70d8d0a83222e94baa" + }, + "Lean.Meta.Tactic.Assert": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Assert.olean", + "sha256": "7673647ca3e547e0078675263dc676f122d87c602266d432c78229cb716be2fe" + }, + "Lean.Meta.Tactic.Assumption": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Assumption.olean", + "sha256": "bbe1c2ac91bb85c39556a28690834034b3faff15ffa79f396f5646154597185b" + }, + "Lean.Meta.Tactic.AuxLemma": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AuxLemma.olean", + "sha256": "b621afecfc83539db089cf44ceee268d994ee0371559db2bafee8341ade61caa" + }, + "Lean.Meta.Tactic.Backtrack": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Backtrack.olean", + "sha256": "6ba89a26edd430b58166fa46607e7b7e7904172b1984de835b7eb9a584fec426" + }, + "Lean.Meta.Tactic.Cases": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Cases.olean", + "sha256": "f82be51283b6ca0a88b466e325061872da1ca78317d784222c2d4d5f095f25d9" + }, + "Lean.Meta.Tactic.Cleanup": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Cleanup.olean", + "sha256": "5daf92f058790a58da353d444701d231bc0d7ffac8ac7a641a396f71c09150d2" + }, + "Lean.Meta.Tactic.Clear": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Clear.olean", + "sha256": "829fa3bd204a603f0686f6060b474f98815ba786324b91fbf166c40783702c4b" + }, + "Lean.Meta.Tactic.Congr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Congr.olean", + "sha256": "2fe9a126baf313a410bca67c2ba600b5397776b3096845ca5bfd4c71f4065195" + }, + "Lean.Meta.Tactic.Constructor": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Constructor.olean", + "sha256": "867577fa39e8b883035764c3dc65017fdb335a365931aab74461676eb3d4ff43" + }, + "Lean.Meta.Tactic.Contradiction": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Contradiction.olean", + "sha256": "4f2fea4e956ca33f43b6958efcba64ec2f7da8199bf2e8305ea09dc0a9a387be" + }, + "Lean.Meta.Tactic.Delta": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Delta.olean", + "sha256": "b80e1e36a4f334d593cc5c2692020ccf113e0066cb9bccf59b88d706a1ed3303" + }, + "Lean.Meta.Tactic.ElimInfo": { + "relative_path": "lib/lean/Lean/Meta/Tactic/ElimInfo.olean", + "sha256": "59a71e16fbbfb5a22573b245e4d7068eee6d9b0d40b49602cdd03e0d4e9bdc5a" + }, + "Lean.Meta.Tactic.ExposeNames": { + "relative_path": "lib/lean/Lean/Meta/Tactic/ExposeNames.olean", + "sha256": "3b31fb2dba571938bce63170aadf82501c229ac457caad8427c58eef935ba444" + }, + "Lean.Meta.Tactic.Ext": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Ext.olean", + "sha256": "22bb0d168e310524c9788a3c415614b51ed048dbfd5a51652f46b0068c77b4a2" + }, + "Lean.Meta.Tactic.FVarSubst": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FVarSubst.olean", + "sha256": "8c21b3a5802e4d08978539b78c1dbb67508903b3f21978b38ef9cc57c270a27c" + }, + "Lean.Meta.Tactic.FunInd": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunInd.olean", + "sha256": "6296c74e67fb553b1bc764a5e07c2d5bbb6c4ebd3b323557c64d01267d1801ab" + }, + "Lean.Meta.Tactic.FunIndCollect": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunIndCollect.olean", + "sha256": "abb578a79335d722c9d69eef073a1ccb64c966b6b7dcdf501b9825181ea2165d" + }, + "Lean.Meta.Tactic.FunIndInfo": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunIndInfo.olean", + "sha256": "7fcea4ed90a733cf9b1d874e6c805f123f293da6379e4a658df2333f64cd5bc5" + }, + "Lean.Meta.Tactic.Generalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Generalize.olean", + "sha256": "c6b2a2530dbb3966ededa8eec4476801bc7c85e1a69c17519d2b47a6e3bb3047" + }, + "Lean.Meta.Tactic.Grind": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind.olean", + "sha256": "a4a04684e58d43aa05cb1c41eb3e18cf6af8da64c935a88fea4b41e394461a78" + }, + "Lean.Meta.Tactic.Grind.Arith": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith.olean", + "sha256": "3cb51d31133b73246d8131265dafb9cede95fc310dbe7bb4b5b7ece65b2598ad" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.olean", + "sha256": "dd481e2963c500cd4c4f686f800ae5d5ab818b1055fcd1cb95bab98516dbf96e" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.olean", + "sha256": "78cc1a489ac6c1dd48dbeae02db742ed4a0867263e877192ab4b417807b73251" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.olean", + "sha256": "bd0a7b837aeda3d44ba972c14219b3f8bf1fda4e68fa1b7b2a98b911007d6ae0" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.olean", + "sha256": "1e84cc67e9674371b9e1ee937f052ebaf33f949ee98fed97ae3e5a0af14ad8bc" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.olean", + "sha256": "bbaf4808f9bef4fd58cffdd9dbbebcaae4a275b740f912f4357bfcd71807dad1" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.olean", + "sha256": "bb82e33912900ffca9cb8b05ba27175bc5be751f59921b09f13322dff9997fdb" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.olean", + "sha256": "868752823c6951c957840f933609d6fe1dc86026fd810479862fdc3c73b84399" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.olean", + "sha256": "8092837e82e32858cfe423c1f20453c3c38a013c54abb05f872b1233cfbe8e5f" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.olean", + "sha256": "370a4249179e8a0d228121d74a22194b50afc23395fcc3d8024621527d703ac1" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.olean", + "sha256": "3c8f3c889d553bf6ef43ed0c444859e905cd162356ce04f85247b0456a4f7b4e" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Search": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.olean", + "sha256": "61aca638560fc03fc81066bda85ae7ed4cd041d810cd6ccfc22126d34acddbd5" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.olean", + "sha256": "50bd8fa6211db0a214bd45a0f0e39b717459c16a30ecb25f9cb952d8375bccef" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.olean", + "sha256": "049f36bd49ee5222ca1f80966c97b13f53c4c7d9671d9cf496d582bf1c502671" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.olean", + "sha256": "d9541c657bbd8498736f341ac0e4389234e57be3d769b33a637f951da6e098f7" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.olean", + "sha256": "2da35cd1a1295137544c382e41dbe533cd98dc6fc18c92de7a0c8986518f48ac" + }, + "Lean.Meta.Tactic.Grind.Arith.Internalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.olean", + "sha256": "1f8dbae8cba46c6011d127e73c6d23e1594b3c13079a8167c9ff0b5d55ceaeb9" + }, + "Lean.Meta.Tactic.Grind.Arith.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Inv.olean", + "sha256": "0750fb3fce8b1e8ec98480b4b6ab8360e5f205371b1d575f53357702ae2bb702" + }, + "Lean.Meta.Tactic.Grind.Arith.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Main.olean", + "sha256": "8eb37977bf901bab0ad9873bfbde7c593fbaf6ff8d0c1c6de61597ec91de58c0" + }, + "Lean.Meta.Tactic.Grind.Arith.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Model.olean", + "sha256": "52f869b8a4523f3f8327495940a786c4670cf48b997d432c20640384e7301003" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset.olean", + "sha256": "bd8b615afcb4c53f5e711d9ab7f88881785088cd9b9f81c6b80b64432a916166" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.olean", + "sha256": "817db989d2e71b096c86076070f270ce02efefcf2c4b0cc8eb35a85ffe592097" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.olean", + "sha256": "3ffe0874b9209d41c8a12f845f4a23c37ed67985952ec8cf4fba6607b0d49bb2" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.olean", + "sha256": "13e17f706763e0e5001c386f41180d240fcc3cb3bb0e5b0704b1c6e89f8690dc" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.olean", + "sha256": "2af0eddf89eb682293b49189b0ecfdb86e7b2cb70ca6983d35edba6fc47b6825" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.olean", + "sha256": "cc0adfcd94231e97e1d8a5d9fd855b4ba06f77d4974d9f60bf8fcb1fad3429cb" + }, + "Lean.Meta.Tactic.Grind.Arith.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Types.olean", + "sha256": "6438183d9d97bcba306b3c98d0c4df35f16ae24156cbd92211a215ee8e0e9508" + }, + "Lean.Meta.Tactic.Grind.Arith.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Util.olean", + "sha256": "059afefed5207fd3bb58ff11aa196e5cb4fdd3d0c2f03f70ab3a302f3fb59612" + }, + "Lean.Meta.Tactic.Grind.Attr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Attr.olean", + "sha256": "e0809449692b76c1e0ae127a742c8c83858306fe2612eb59a238e5600e6437b0" + }, + "Lean.Meta.Tactic.Grind.Beta": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Beta.olean", + "sha256": "34027591ddea6317ba5bc6f29ec01c6a1cd2dc75c8b2af5b5d5e6fede7c2813f" + }, + "Lean.Meta.Tactic.Grind.Canon": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Canon.olean", + "sha256": "7e0dcfb39fd87bd7aa566da21f8cf3e0055adf5abdfab8c4dcd92ff022cffc99" + }, + "Lean.Meta.Tactic.Grind.Cases": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Cases.olean", + "sha256": "a79fdef9eaf0a5a89b2369d0374b43efa50ef7eb137bb143aea1b6968130fcd5" + }, + "Lean.Meta.Tactic.Grind.CasesMatch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/CasesMatch.olean", + "sha256": "cae5f088bd9191b15683eb230c385d3cf95b9cc36c5aa8fd237ef6abd6240e79" + }, + "Lean.Meta.Tactic.Grind.Combinators": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Combinators.olean", + "sha256": "573a8a2af44136b8fde8d93f561948f97b61ed2b0445b4af06a07e82901b004c" + }, + "Lean.Meta.Tactic.Grind.Core": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Core.olean", + "sha256": "603facdbeba83aeb053dc352948b86af9017b6a6e7b546a1a1516f03fea9c273" + }, + "Lean.Meta.Tactic.Grind.Ctor": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Ctor.olean", + "sha256": "2e49aeb70d54c80eecfae5c718a65d31917c4d875090b306049d463db43c230b" + }, + "Lean.Meta.Tactic.Grind.Diseq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Diseq.olean", + "sha256": "712b2965e98032727d42acecf75d2845c6d20828c9aa6f4cb7346b51100c6761" + }, + "Lean.Meta.Tactic.Grind.EMatch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatch.olean", + "sha256": "b3075bba2fa4af4839446ccc345b04063a1eeaf1f396aa027550e0d67eaf46d6" + }, + "Lean.Meta.Tactic.Grind.EMatchTheorem": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.olean", + "sha256": "7e393dd56ee80f27d92e457f4c2070d2fe2831142981438b7dff6b652ed6b12e" + }, + "Lean.Meta.Tactic.Grind.ENodeKey": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ENodeKey.olean", + "sha256": "ca0345179b9421b8efb30bed06820116843d9701e9c9f84e0824a0961b5251a5" + }, + "Lean.Meta.Tactic.Grind.EqResolution": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EqResolution.olean", + "sha256": "ed9d38ede8c44a14131ac484fcaac127fd889468856ea78f158cb8f7c7c5f9e1" + }, + "Lean.Meta.Tactic.Grind.Ext": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Ext.olean", + "sha256": "a7c1cee7f1e76d45b3787d0a7c2036967fffd7c6d780dad968bc5e08e0c674c7" + }, + "Lean.Meta.Tactic.Grind.ForallProp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ForallProp.olean", + "sha256": "923892a0ed79c2156b6df9cc23f561b77dc2c935ccb9b1d95122bab0e20fef97" + }, + "Lean.Meta.Tactic.Grind.Injection": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Injection.olean", + "sha256": "7c448e2fc0d16e61b6ad822651c7b35b8213dd18fbd4927017595d9fcd96af63" + }, + "Lean.Meta.Tactic.Grind.Internalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Internalize.olean", + "sha256": "7cd74b074c2e9deae6791b7045b6dec8f9056d41b96c9072020b051d67402323" + }, + "Lean.Meta.Tactic.Grind.Intro": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Intro.olean", + "sha256": "45d35493ac631af84097a78ea4b02bc5cc814c0ac8b598b36049279ac7ed87f3" + }, + "Lean.Meta.Tactic.Grind.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Inv.olean", + "sha256": "5111a484cd46c8d2263629540e4128cef9f30b74ccf62a6eded8ac56d8481fa3" + }, + "Lean.Meta.Tactic.Grind.MBTC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MBTC.olean", + "sha256": "596858a07ca041824937bfd08b38cdef09d32b08749962546f2b8abdb7e24192" + }, + "Lean.Meta.Tactic.Grind.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Main.olean", + "sha256": "e1e5ab7d0c967a50c2a38a5490a1a8c537e843da2c3f5a56e7cda971208bfd93" + }, + "Lean.Meta.Tactic.Grind.MarkNestedProofs": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MarkNestedProofs.olean", + "sha256": "3ab8dc54fab42c6683c63aae87ad0e606b3832d1f2391087ec7e698d5fa2fbcb" + }, + "Lean.Meta.Tactic.Grind.MatchCond": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchCond.olean", + "sha256": "ab35239747c6ca8c3833e709aaa2aa723d0525620ac2634241f72963ac9bed82" + }, + "Lean.Meta.Tactic.Grind.MatchDiscrOnly": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.olean", + "sha256": "0de0cdfbedfabfa048e98e885f3f1eea39e583aec8bcc2a50a5698f7a0df7884" + }, + "Lean.Meta.Tactic.Grind.PP": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/PP.olean", + "sha256": "23d560a5339928172099a9062d083f940a0a16e6c0b784dfe2a9f356e8682bb7" + }, + "Lean.Meta.Tactic.Grind.Parser": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Parser.olean", + "sha256": "052643551a1eb5fbfe4afdca2eb7ae6260628ef93f4813744cbda5a138eb751a" + }, + "Lean.Meta.Tactic.Grind.Proj": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Proj.olean", + "sha256": "1383ad6bc4a47cea522c9b9f542049aad4b818f4bf208ed98d1f56088d322a9a" + }, + "Lean.Meta.Tactic.Grind.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Proof.olean", + "sha256": "7e5f3d9016d71c938eb5bf7c6188d50dfe2b148189748b018e13d1d1f26758c0" + }, + "Lean.Meta.Tactic.Grind.Propagate": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Propagate.olean", + "sha256": "ba25b0259e25398cb28d7a6343b76a9ffae30a0e7759f2bbba03cf439d27ee49" + }, + "Lean.Meta.Tactic.Grind.PropagatorAttr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.olean", + "sha256": "c21c3865df64f8a2bdab20ab5a5658badebe0b370640e63e7ce8ae0620bc98b3" + }, + "Lean.Meta.Tactic.Grind.ProveEq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ProveEq.olean", + "sha256": "6fd15eeee6dce37a980a5036eb99716960dbbc6650d14b71cbd63a0f854578e7" + }, + "Lean.Meta.Tactic.Grind.RevertAll": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/RevertAll.olean", + "sha256": "63335a05f51b1b99b3bc891e774ed07ae7ccf470b36701c9a47472a2023b72dc" + }, + "Lean.Meta.Tactic.Grind.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Simp.olean", + "sha256": "eb9a419af181bdcc13018b73f8b5ef9b0cce6b3d8e69bb777a9464d54d7489d0" + }, + "Lean.Meta.Tactic.Grind.SimpUtil": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/SimpUtil.olean", + "sha256": "082ec13ed64da168e10a1d19d1f2080f417e069936488d9628652d2e83bf96ab" + }, + "Lean.Meta.Tactic.Grind.Solve": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Solve.olean", + "sha256": "838552f0e3f9901c03de3ee16533956fcc7677abcd393eaa85fc7e14c67c0c07" + }, + "Lean.Meta.Tactic.Grind.Split": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Split.olean", + "sha256": "9be21a776a8dbb641a0af947eebf4525341bfa829b3ae7e7ed5eb20855727d37" + }, + "Lean.Meta.Tactic.Grind.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Types.olean", + "sha256": "50bd2bb81627e5f915ee54c8730bb4d5403de12cca8a05a41f2f280b693772f9" + }, + "Lean.Meta.Tactic.Grind.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Util.olean", + "sha256": "02603b8094844f61ba32b6173beb06896e101dac5d581ca4ef9e82b17f4ba473" + }, + "Lean.Meta.Tactic.IndependentOf": { + "relative_path": "lib/lean/Lean/Meta/Tactic/IndependentOf.olean", + "sha256": "d6abc51e9488051912586a96926f55ddb9f0368c8891d5f89ff2d684122148fe" + }, + "Lean.Meta.Tactic.Induction": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Induction.olean", + "sha256": "a8fdc96571cc600fd47e2e68d84c51fe8afc537c08ab63d1e69ba5b4f518f4fa" + }, + "Lean.Meta.Tactic.Injection": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Injection.olean", + "sha256": "6d25fe6e9d8e4af470d9cd1074402577fd08575b0306faf9c78411c8a5e7578a" + }, + "Lean.Meta.Tactic.Intro": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Intro.olean", + "sha256": "a781ab0eafda9549477f2e90e0dc6ea708bbbda6d12f7390eaba879ecf6146a7" + }, + "Lean.Meta.Tactic.LibrarySearch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/LibrarySearch.olean", + "sha256": "c943f49809c5e0037e4239b05e441c2331cb48b24ca17f9146e5197458ed3ad6" + }, + "Lean.Meta.Tactic.NormCast": { + "relative_path": "lib/lean/Lean/Meta/Tactic/NormCast.olean", + "sha256": "8758122a8aa03b65194824837c9501ff7a57f6e56c3645ce16cd39935122465b" + }, + "Lean.Meta.Tactic.Refl": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Refl.olean", + "sha256": "39762b479efc2290610ab53ea0f9a7a67643f6684cb0fa5cdc1ff52cd5589d8a" + }, + "Lean.Meta.Tactic.Rename": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rename.olean", + "sha256": "633edd2088d9aab13bbb93c7da98451571c025dd4fa28c7adb7a1f14dede0a82" + }, + "Lean.Meta.Tactic.Repeat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Repeat.olean", + "sha256": "54854192d18a935b34a838ec68e7b5c86f7efc2831bbfe623057415260b84553" + }, + "Lean.Meta.Tactic.Replace": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Replace.olean", + "sha256": "a542783069ace49d9d9e92aa9f3cb725c98f94d5cdd4977a1154569dad20f1b5" + }, + "Lean.Meta.Tactic.Revert": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Revert.olean", + "sha256": "f6454fe8a940ada423be12c9a36033ecfbba13b71d0ed59fad2e9d522d46df10" + }, + "Lean.Meta.Tactic.Rewrite": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rewrite.olean", + "sha256": "3d61c66d1f775792f0c463b3ef6666a399fff92c2f7f1b29c605c99e02941897" + }, + "Lean.Meta.Tactic.Rewrites": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rewrites.olean", + "sha256": "5a2278edd2383bca036422ea43a484ccae7a0bb2bc7e7e15f0326a32e2330786" + }, + "Lean.Meta.Tactic.Rfl": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rfl.olean", + "sha256": "d2e5e722c4f2e3c9f291c02c05a671917d71aef645e34c0c01dbfd8a4ef23898" + }, + "Lean.Meta.Tactic.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp.olean", + "sha256": "a744b6973cd9b833699a6c19c0fa40e4dbfb6041fb08a6ca4de0823d3d56fae0" + }, + "Lean.Meta.Tactic.Simp.Arith": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith.olean", + "sha256": "b8b2030520be215f2121c9fab8608f7fd58ea80e48ffa5598fce3d1f948950c1" + }, + "Lean.Meta.Tactic.Simp.Arith.Int": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int.olean", + "sha256": "4f1c85c9e598fc31a7e1fc7e6f8d06d1c1eaa5146c624842e8ec87b58e5d9994" + }, + "Lean.Meta.Tactic.Simp.Arith.Int.Basic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.olean", + "sha256": "d03e49ecd4dfdec58f2ac9f261d983bea4023df4c78f7514bb7f6c40cdbb8bbf" + }, + "Lean.Meta.Tactic.Simp.Arith.Int.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.olean", + "sha256": "2766ba66e280f3beb4bae57de6de59a2f92647472cbe608bec350dbabdaaba11" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat.olean", + "sha256": "a035ca9e9317ad56e2e70046e0864586827218ad7e25cb7366fe532e010b1007" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat.Basic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.olean", + "sha256": "f80614c7ae4ff336b04162d11f2574e0848f38f72882fe919d759eaa09590f72" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.olean", + "sha256": "d77e898ebdaa21da0b6f6fa24eb4804a8b45ecf4ed7834aa26bfe8493b51148a" + }, + "Lean.Meta.Tactic.Simp.Arith.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Util.olean", + "sha256": "e43e2fa36cc77656ee34ca02b79897664215ce95e653cada87db0781111193ff" + }, + "Lean.Meta.Tactic.Simp.Attr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Attr.olean", + "sha256": "59dacc00728793da658e06c75bf20eb166ca57c100434714c7a7b7349149e99b" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.olean", + "sha256": "9e91488ad971f433fc8c18b870ddae5174f4fd8a80f9aee7e195223acf0813e7" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.olean", + "sha256": "aba24528cdf8549fefad4371d2ed8279dcc5bd4566d9ca59ccc721f760d51c56" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.olean", + "sha256": "18ba1c46202bae2dd5205e93db1df217fc9d213fbdc687452d9d76421437ef66" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.olean", + "sha256": "70bb04834a476008fe448165e8662a0437c82012e348ec19b6039773051fc91d" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.olean", + "sha256": "5b8217fa58f2deae0b8a99202da2367fedbf91cda77486d0ea9201b05a0720ae" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.olean", + "sha256": "fe618da592aafcfc1b597b118c88b962b603f55096926e7c77cd5f237a393c0e" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.olean", + "sha256": "9535c409ebeb0c3064e5b98fa9f953fbb93e15db3f2116dc46138ac0ff700c0a" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.List": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.olean", + "sha256": "93a9382bd2f855ac48c61e6886f02b85f81593552747a1dae72b3b10afc71a70" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.olean", + "sha256": "6b8d3d8807c31912616ae4818014da1e44cbfa398eeae525170b864185b3f324" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.olean", + "sha256": "a14d545e6a296624fbfc25dc02e8a49e0be6e3285f47960af9dbb766e872a024" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.String": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.olean", + "sha256": "bae98881832f2482d6e98c1b9eb11cc28e984ee2b7ac2d3e3d92ceade31bb7c6" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.olean", + "sha256": "9afaab454e44fd3c1a60907f38ee31b9057682bb6b66503e3136b23a0e51a0eb" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.olean", + "sha256": "97194969f1662051ced0134ccd1cbc4051c02ed0afd46ecff6daafb413645652" + }, + "Lean.Meta.Tactic.Simp.Diagnostics": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Diagnostics.olean", + "sha256": "8fb74efbbe0d898b4bee2b53a996bb925cd3dfdd4bf3098086d07fdad9c093f6" + }, + "Lean.Meta.Tactic.Simp.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Main.olean", + "sha256": "90f3c5c41d8d10a7b82110a9d188db8661f730c8430102696a6050a9e819944d" + }, + "Lean.Meta.Tactic.Simp.RegisterCommand": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/RegisterCommand.olean", + "sha256": "5e296fcd42394e5fa5a137358753eb347872076a0e8dc3ef5e31b483ac58af39" + }, + "Lean.Meta.Tactic.Simp.Rewrite": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Rewrite.olean", + "sha256": "e6377cde2f937751efc04e43b032505bfed7ec5c1f13678c3cb456268e90d2c2" + }, + "Lean.Meta.Tactic.Simp.SimpAll": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpAll.olean", + "sha256": "f2aedf17c8196a3fcc3ba0a79d2dee82b6599e2623e0e5336940943fe294316d" + }, + "Lean.Meta.Tactic.Simp.SimpCongrTheorems": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.olean", + "sha256": "2a29138060df8d5e09ad070b170d167fc490713073b36b38371e676c83578119" + }, + "Lean.Meta.Tactic.Simp.SimpTheorems": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpTheorems.olean", + "sha256": "b6f48b1bf34a7832d9a809b108a3aa8606c13afd2376b6c2c79f7045425e0e7d" + }, + "Lean.Meta.Tactic.Simp.Simproc": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Simproc.olean", + "sha256": "913ac372ccd4b4445b346d16d2ba702bf74d8ea65e62401b7b502b016bc82750" + }, + "Lean.Meta.Tactic.Simp.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Types.olean", + "sha256": "382bf34c3320d34ce0ba097804f91ee702480fb358709d1a376399ab20ae2767" + }, + "Lean.Meta.Tactic.SolveByElim": { + "relative_path": "lib/lean/Lean/Meta/Tactic/SolveByElim.olean", + "sha256": "65859e5f73882352b2e665afdd9ae7f9dbd122ef99cdaa6422fc4e37c030d459" + }, + "Lean.Meta.Tactic.Split": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Split.olean", + "sha256": "0e8d4c9c735a78acc8977e81bc84bd39d2390093d889445f006ba6d5f6ad5b3d" + }, + "Lean.Meta.Tactic.SplitIf": { + "relative_path": "lib/lean/Lean/Meta/Tactic/SplitIf.olean", + "sha256": "a39ffae4f96a41e30a2c3a88468103c3c716942214fc8805357490e903b2ef67" + }, + "Lean.Meta.Tactic.Subst": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Subst.olean", + "sha256": "44938a993d4998ad3140ba161843cf52fc0f01d8eb04dc105433e74f57e13dba" + }, + "Lean.Meta.Tactic.Symm": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Symm.olean", + "sha256": "9e576fa9ccc14f72a6d4b75f9ccb133f5463c531031fc0abcd81f9ce1e002b6b" + }, + "Lean.Meta.Tactic.Try": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Try.olean", + "sha256": "e2c566144935639f447b2493030d97204d22cfb866bd8c767ec0fba491cb56c2" + }, + "Lean.Meta.Tactic.Try.Collect": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Try/Collect.olean", + "sha256": "eb58abadce47d13437cc648de8c9c4d34965bde2b5b8c0fb5be46aa7c2f709bb" + }, + "Lean.Meta.Tactic.TryThis": { + "relative_path": "lib/lean/Lean/Meta/Tactic/TryThis.olean", + "sha256": "b0a43bfa4c21d9d9c9181de4783e7f7637862e6799dc17a94ffd41b6b8320535" + }, + "Lean.Meta.Tactic.Unfold": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Unfold.olean", + "sha256": "c512bf7a8ddc53bc480ed017efccdce73fa6a65ff3bc8026fcdb45108910a8f1" + }, + "Lean.Meta.Tactic.UnifyEq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/UnifyEq.olean", + "sha256": "17895f0232b1c9b37739a6678bc125d5481c4711fd70dcc2e0d7533d2ae7d88a" + }, + "Lean.Meta.Tactic.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Util.olean", + "sha256": "26f024806a3c5a844167cad452c161e17dd535f37c2f70f76fa8d0e98ac7d898" + }, + "Lean.Meta.Transform": { + "relative_path": "lib/lean/Lean/Meta/Transform.olean", + "sha256": "0fad85dd417e805f932c54eada13d21053a7457b9154026cf16b38e3458fc759" + }, + "Lean.Meta.TransparencyMode": { + "relative_path": "lib/lean/Lean/Meta/TransparencyMode.olean", + "sha256": "8f195daac0641aeeb14c47bb8989f99929ddb79329d5b64dd4349bc21ad52fdc" + }, + "Lean.Meta.UnificationHint": { + "relative_path": "lib/lean/Lean/Meta/UnificationHint.olean", + "sha256": "f6400a3713e4a9a72e4f2ef064ebe692706c0f21f186dce75250fe6eb4138a85" + }, + "Lean.Meta.WHNF": { + "relative_path": "lib/lean/Lean/Meta/WHNF.olean", + "sha256": "13939b1cdb2a81230a5445e9836dadeead92b5810b293c5da265451f02dd516f" + }, + "Lean.MetavarContext": { + "relative_path": "lib/lean/Lean/MetavarContext.olean", + "sha256": "616fb991aae42c8780c3566eadfe5e7cbabbf4779da1cf138014130772a668e1" + }, + "Lean.Modifiers": { + "relative_path": "lib/lean/Lean/Modifiers.olean", + "sha256": "34a8b59c7358c3a176430743f45ff649c47511e16e8b38bc763e3d63d82d11ae" + }, + "Lean.MonadEnv": { + "relative_path": "lib/lean/Lean/MonadEnv.olean", + "sha256": "086512b6ccf3afb524b665d93bfa512c8d2f699dd55ee4d59acab9376c379659" + }, + "Lean.Namespace": { + "relative_path": "lib/lean/Lean/Namespace.olean", + "sha256": "a4eb3519381836c10a0afd99e58a248135c277cd2a9489cc77636877914df692" + }, + "Lean.Parser": { + "relative_path": "lib/lean/Lean/Parser.olean", + "sha256": "28d395e6f52a72577be7747cfd60a84d5fef0edbff614963675e7103f43ce066" + }, + "Lean.Parser.Attr": { + "relative_path": "lib/lean/Lean/Parser/Attr.olean", + "sha256": "d37af508df519b54e878fdf29c6ff2006c4ab3d66c189302f2e28d50fb53d01e" + }, + "Lean.Parser.Basic": { + "relative_path": "lib/lean/Lean/Parser/Basic.olean", + "sha256": "948a51872ed931dcd069d6717532f02760ec64f1acfd6862fc5d222cc6aedeb0" + }, + "Lean.Parser.Command": { + "relative_path": "lib/lean/Lean/Parser/Command.olean", + "sha256": "a095b104d809b21d76722139623c677f932cbe8f33f79077c0f7469facaa4d21" + }, + "Lean.Parser.Do": { + "relative_path": "lib/lean/Lean/Parser/Do.olean", + "sha256": "0d97f39e5ec556f827c8399724fc2c7ad26b9b7a3aa8583158c1b335d2962edc" + }, + "Lean.Parser.Extension": { + "relative_path": "lib/lean/Lean/Parser/Extension.olean", + "sha256": "3d5387205b22b17b0449553339d1449481eb01d1f90424c1920521dfbbd6a51d" + }, + "Lean.Parser.Extra": { + "relative_path": "lib/lean/Lean/Parser/Extra.olean", + "sha256": "26993ef7f1b0dc107e5a54f5346becb1ed7df9e287a9716ba9a90dc25cb5597a" + }, + "Lean.Parser.Level": { + "relative_path": "lib/lean/Lean/Parser/Level.olean", + "sha256": "028076fe879c3d1f470248400637a3b2a404bd2807c6b1c42bd9f19b37a87385" + }, + "Lean.Parser.Module": { + "relative_path": "lib/lean/Lean/Parser/Module.olean", + "sha256": "1cd96b90357d48c1313be94c170a60e06deab7c2230a7684a5d3ad39a41a1453" + }, + "Lean.Parser.StrInterpolation": { + "relative_path": "lib/lean/Lean/Parser/StrInterpolation.olean", + "sha256": "1f275289f803e6362acbbdbb64dcbd1f4b63a25d01b96104d8bad7419712270a" + }, + "Lean.Parser.Syntax": { + "relative_path": "lib/lean/Lean/Parser/Syntax.olean", + "sha256": "b7d13deae25970c03965ab71ee15b6079948b4031f5c7877b19253d75b32a9a8" + }, + "Lean.Parser.Tactic": { + "relative_path": "lib/lean/Lean/Parser/Tactic.olean", + "sha256": "1d5f60bbb0520f7381c7942188f25406b178ed74e64c6995b8136e9d410617c9" + }, + "Lean.Parser.Tactic.Doc": { + "relative_path": "lib/lean/Lean/Parser/Tactic/Doc.olean", + "sha256": "de5fa176afd2efb06130e19b1fad85a782e8f6c70abd81e07410c06bdaaf435c" + }, + "Lean.Parser.Term": { + "relative_path": "lib/lean/Lean/Parser/Term.olean", + "sha256": "c27cd04030908ee1296d32a8230508cf878e37d3d9b55dc54a33dfd8f7bbcbaf" + }, + "Lean.Parser.Term.Doc": { + "relative_path": "lib/lean/Lean/Parser/Term/Doc.olean", + "sha256": "48344268b22b852d1c35ae1a717dcd804b7e02cb6619538b521a0f9f7c5b75ec" + }, + "Lean.Parser.Types": { + "relative_path": "lib/lean/Lean/Parser/Types.olean", + "sha256": "ebb9269d0c74ef1b84ed10af9a0fcfebd8c5f06af78ea8b7de52fab501ec3801" + }, + "Lean.ParserCompiler": { + "relative_path": "lib/lean/Lean/ParserCompiler.olean", + "sha256": "dfcf227a5095244c4f18259255e84b7d7486916a13d15cc7d494bf8327e7ea01" + }, + "Lean.ParserCompiler.Attribute": { + "relative_path": "lib/lean/Lean/ParserCompiler/Attribute.olean", + "sha256": "0635f545bec6dc4635f71024582d1e77d8ea6ace85b71d596c241b8c5cbb7ae0" + }, + "Lean.PremiseSelection": { + "relative_path": "lib/lean/Lean/PremiseSelection.olean", + "sha256": "84ad62edb54be2f55ea548421e59915503f678f5a689528429cbd6b3a47f52c3" + }, + "Lean.PrettyPrinter": { + "relative_path": "lib/lean/Lean/PrettyPrinter.olean", + "sha256": "f3c54ec68adb7b306e7de49fe6e1cc53c591053f6d772c125120e35cc0e42762" + }, + "Lean.PrettyPrinter.Basic": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Basic.olean", + "sha256": "5c155123ea1a5935403072f161006d3609e769fa5971cc83b99217c93d269a70" + }, + "Lean.PrettyPrinter.Delaborator": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator.olean", + "sha256": "2832e05f38fb87dd795cde9f6529793009807c6599a36ca0655f04eceb2c216c" + }, + "Lean.PrettyPrinter.Delaborator.Attributes": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Attributes.olean", + "sha256": "f98afcbf332723561b6d466a6c129844cdaff8b8f55e79f43a0040d1a0eb6a5c" + }, + "Lean.PrettyPrinter.Delaborator.Basic": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Basic.olean", + "sha256": "e402ce6c7c87da5752f1ec58b3032275db4ee722342a55bc118ac16ccb31b129" + }, + "Lean.PrettyPrinter.Delaborator.Builtins": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Builtins.olean", + "sha256": "02e8e2ec8a01f0eeba7212f5f3731bad7811680c44c03045391acd6222e8246a" + }, + "Lean.PrettyPrinter.Delaborator.FieldNotation": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.olean", + "sha256": "0fd7dac9c26de870462ff5c02bfa167ddba6d4b6f5616e9cd0849bf410997dc1" + }, + "Lean.PrettyPrinter.Delaborator.Options": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Options.olean", + "sha256": "83038fe17fe8486d5c2d49c942c60f40a56a857ea203991d52b0877f4c96ebdd" + }, + "Lean.PrettyPrinter.Delaborator.SubExpr": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/SubExpr.olean", + "sha256": "0d284ad4e40cc16bff17d232de10dee13bfa15b68eeda439218984488a864cef" + }, + "Lean.PrettyPrinter.Delaborator.TopDownAnalyze": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.olean", + "sha256": "ae6466c25b02f08e0b5fdfa1d2905b521de447c99ed580026aeaf3fcbac14d54" + }, + "Lean.PrettyPrinter.Formatter": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Formatter.olean", + "sha256": "348c5cf96f47b9c3b5d672b87913ac267d4c9f6ab5cc6e1e46757b9a4898470f" + }, + "Lean.PrettyPrinter.Parenthesizer": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Parenthesizer.olean", + "sha256": "d11ccf31a884b96dd8e7ce4a3d0be88ee37572282cc77235996eb06283ff9e1e" + }, + "Lean.PrivateName": { + "relative_path": "lib/lean/Lean/PrivateName.olean", + "sha256": "01331d62033f1a153ccfce0e26b19eec216989653b9170e09690f3f30017cd9e" + }, + "Lean.ProjFns": { + "relative_path": "lib/lean/Lean/ProjFns.olean", + "sha256": "b4e573e1214a33dfb17c70b252e55c42d56cbaa3ee3a02b620fc3cb238587772" + }, + "Lean.ReducibilityAttrs": { + "relative_path": "lib/lean/Lean/ReducibilityAttrs.olean", + "sha256": "4474586ad1da6481575424de924659c612a3e8c6b715ddf34fc26039d2e51e29" + }, + "Lean.Replay": { + "relative_path": "lib/lean/Lean/Replay.olean", + "sha256": "b99332f1e48cab089d45ecc5b6fadb71f95adb915b95ac7d5f513b8866b65d4e" + }, + "Lean.ReservedNameAction": { + "relative_path": "lib/lean/Lean/ReservedNameAction.olean", + "sha256": "c4c0b3460d35f4083a2459f232a0ff881e69092173963b6a671550a8640b3b41" + }, + "Lean.ResolveName": { + "relative_path": "lib/lean/Lean/ResolveName.olean", + "sha256": "1c5302ed5d1925a703364dbb22a84eb835a738d1073a1f576eafb4551b2f6863" + }, + "Lean.Runtime": { + "relative_path": "lib/lean/Lean/Runtime.olean", + "sha256": "f2c44c67f19cf22efd8c35ebb08d645de14a15341ce43055392e503f90c96ebf" + }, + "Lean.ScopedEnvExtension": { + "relative_path": "lib/lean/Lean/ScopedEnvExtension.olean", + "sha256": "a81bf05e51a27486ca11bb4b7f627a71278be383d69c04380886f8be0d7fd0fe" + }, + "Lean.Server": { + "relative_path": "lib/lean/Lean/Server.olean", + "sha256": "bbd9570762b5728fbeba1cd4fb6e1e63d0dc1e2f2b117cafd9e7fcae9bad7637" + }, + "Lean.Server.AsyncList": { + "relative_path": "lib/lean/Lean/Server/AsyncList.olean", + "sha256": "d9ecedd556a8565e22c4c4ef375e498bcf46cff541631685e3c6bb59da13ec06" + }, + "Lean.Server.CodeActions": { + "relative_path": "lib/lean/Lean/Server/CodeActions.olean", + "sha256": "1ffd438b12bf14992169052902dc91ff981fbffbd5b9d9dc3cd351afadf2d924" + }, + "Lean.Server.CodeActions.Attr": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Attr.olean", + "sha256": "21177a969ea2086c19c19a7d71a2d66acd666bfbd49c77dff89a2193ab911100" + }, + "Lean.Server.CodeActions.Basic": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Basic.olean", + "sha256": "3092af6beab4d2ccbcdc4d3c493887fbc61d2fd8c6507359d8dc81515af83350" + }, + "Lean.Server.CodeActions.Provider": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Provider.olean", + "sha256": "aca19e7414b6c15aa725debc884e06aa48515bc10f78bdac847e92a0d3355945" + }, + "Lean.Server.Completion": { + "relative_path": "lib/lean/Lean/Server/Completion.olean", + "sha256": "2d2b0e130132eee10776deb68540afbf5c588598b4f858be9850099e64e8039e" + }, + "Lean.Server.Completion.CompletionCollectors": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionCollectors.olean", + "sha256": "ca660a9b742f1e2f6adf50cc33847122c9bc017880a643d63a56053091cb9f8d" + }, + "Lean.Server.Completion.CompletionInfoSelection": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionInfoSelection.olean", + "sha256": "229a4e0e5238f4af4a9165f077e381a739b385a957ec1fe5590d0329711a221d" + }, + "Lean.Server.Completion.CompletionItemData": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionItemData.olean", + "sha256": "aa592a1060191b06553a282b4e2c23583260bbd32f193fdd82a2a0e3881b2ea5" + }, + "Lean.Server.Completion.CompletionResolution": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionResolution.olean", + "sha256": "1f1e99acc389c5ef5818bcc8c7c5e2a2ed0058e0be93661a2b2aaf6c4ccf3220" + }, + "Lean.Server.Completion.CompletionUtils": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionUtils.olean", + "sha256": "1b68673e815b0792013d12790d4bcf8768326df0b7ff0244cf27d3b1fb4603d7" + }, + "Lean.Server.Completion.EligibleHeaderDecls": { + "relative_path": "lib/lean/Lean/Server/Completion/EligibleHeaderDecls.olean", + "sha256": "f71255170c2f18efa266279cda6ec56942e0975689ccd22ec7eaaff127d8433b" + }, + "Lean.Server.Completion.ImportCompletion": { + "relative_path": "lib/lean/Lean/Server/Completion/ImportCompletion.olean", + "sha256": "aed78476c5e3c1d841563b30a1076e4d8392383fc0ba65273f50f96057bb3a5e" + }, + "Lean.Server.Completion.SyntheticCompletion": { + "relative_path": "lib/lean/Lean/Server/Completion/SyntheticCompletion.olean", + "sha256": "6d1733deb5c375a5d09f69a8719d6f0cd91659aac517071e22d50d8c1072d2ca" + }, + "Lean.Server.FileSource": { + "relative_path": "lib/lean/Lean/Server/FileSource.olean", + "sha256": "e28757c52a99267f3c788a9e83b0d30a1461d4113065f45444269fdf7b18f9ae" + }, + "Lean.Server.FileWorker": { + "relative_path": "lib/lean/Lean/Server/FileWorker.olean", + "sha256": "f6529233eb4cc58fd4ce7426ece4285e7b294fcd924f80e60759a609ce75ab4c" + }, + "Lean.Server.FileWorker.ExampleHover": { + "relative_path": "lib/lean/Lean/Server/FileWorker/ExampleHover.olean", + "sha256": "159199fc8757162b59d3e4882a5adde20b9d30f1e1c2e9d73f2d431d8225f8b2" + }, + "Lean.Server.FileWorker.InlayHints": { + "relative_path": "lib/lean/Lean/Server/FileWorker/InlayHints.olean", + "sha256": "a6a0a9f601e15e5f0a4f1a4c58cccfa47a090ddcea06b087cf4d35f83bc8acb8" + }, + "Lean.Server.FileWorker.RequestHandling": { + "relative_path": "lib/lean/Lean/Server/FileWorker/RequestHandling.olean", + "sha256": "bb4929eaa8e2895d7dede2dfcee916694296993384310e57cb44c2f207c769cb" + }, + "Lean.Server.FileWorker.SemanticHighlighting": { + "relative_path": "lib/lean/Lean/Server/FileWorker/SemanticHighlighting.olean", + "sha256": "18293c05d11ec7a4479e7139013a5da2244e92d2a15f6fe0683f5aa25910839c" + }, + "Lean.Server.FileWorker.SetupFile": { + "relative_path": "lib/lean/Lean/Server/FileWorker/SetupFile.olean", + "sha256": "6aadbc90fb133de6196241264b5e9199eb20873ac28c97fd525020b9d1ff8117" + }, + "Lean.Server.FileWorker.Utils": { + "relative_path": "lib/lean/Lean/Server/FileWorker/Utils.olean", + "sha256": "fb1141d854ddd8285b816247a29f6c73f55bdbb57598d5b23b5689b2dd5bc6b4" + }, + "Lean.Server.FileWorker.WidgetRequests": { + "relative_path": "lib/lean/Lean/Server/FileWorker/WidgetRequests.olean", + "sha256": "b6a3538e82fcf0053a603dd6b89dae5ac056f25833d5af7671d9f5730eccc0be" + }, + "Lean.Server.GoTo": { + "relative_path": "lib/lean/Lean/Server/GoTo.olean", + "sha256": "18aa8fbcc0ca8c945db6e6aa3eed8ed4ca27a7c9e08ba86af3f8be0828608cf4" + }, + "Lean.Server.InfoUtils": { + "relative_path": "lib/lean/Lean/Server/InfoUtils.olean", + "sha256": "77b7e95c6f553154b841639d2aa3bb24346e89434327ddcb557b5982e4de69de" + }, + "Lean.Server.References": { + "relative_path": "lib/lean/Lean/Server/References.olean", + "sha256": "de438915fcb962e19d09bfd1905df6632459853730bf416cbe9c1bcae4fe515f" + }, + "Lean.Server.RequestCancellation": { + "relative_path": "lib/lean/Lean/Server/RequestCancellation.olean", + "sha256": "cd8942ec9337da649a58c9f8ea7f01ecce2383c59e080f22116f48f386be3ee0" + }, + "Lean.Server.Requests": { + "relative_path": "lib/lean/Lean/Server/Requests.olean", + "sha256": "0ae37f883b90fbbbb165411871f2f1bf1cc6f166efca062dd8869f14c845c828" + }, + "Lean.Server.Rpc": { + "relative_path": "lib/lean/Lean/Server/Rpc.olean", + "sha256": "640216f0a569300668056ade5912685e2a0543328feba76d00a752859c3b692d" + }, + "Lean.Server.Rpc.Basic": { + "relative_path": "lib/lean/Lean/Server/Rpc/Basic.olean", + "sha256": "09a13a5b0eb1c751cf1689334e7d858d4db582a65bd458efd638a20153839f73" + }, + "Lean.Server.Rpc.Deriving": { + "relative_path": "lib/lean/Lean/Server/Rpc/Deriving.olean", + "sha256": "398279634e15fa8d0aa9394bc63d5ec59a867598db64d76e4772549ba8d29aec" + }, + "Lean.Server.Rpc.RequestHandling": { + "relative_path": "lib/lean/Lean/Server/Rpc/RequestHandling.olean", + "sha256": "0af5a93b3960757ec7bc913b866e9c8bb12a0d3d966d5701f526174d53342c8e" + }, + "Lean.Server.ServerTask": { + "relative_path": "lib/lean/Lean/Server/ServerTask.olean", + "sha256": "5b6e96d39b1fb04527dfe5efb97b1118c1947d723f31cac6c97f8815ad8624a5" + }, + "Lean.Server.Snapshots": { + "relative_path": "lib/lean/Lean/Server/Snapshots.olean", + "sha256": "0fc97604d59c24d8ee81fd5a63dc5ae1abbdc7f9d88e4cdb15eaaee0d0da0991" + }, + "Lean.Server.Test": { + "relative_path": "lib/lean/Lean/Server/Test.olean", + "sha256": "2afbefa351dbf1bcf23b5bfaad40f909905680ad39e528f867b4c463d3db58b1" + }, + "Lean.Server.Test.Cancel": { + "relative_path": "lib/lean/Lean/Server/Test/Cancel.olean", + "sha256": "f33dbeb8bdf19c481feee5ee16bae1d773e043a294995bd4a11f94f604b8771b" + }, + "Lean.Server.Test.Runner": { + "relative_path": "lib/lean/Lean/Server/Test/Runner.olean", + "sha256": "1c8d1946a902c7331616a9a9f7be3d8db6dd5bbe233698c23150fa37043b147d" + }, + "Lean.Server.Utils": { + "relative_path": "lib/lean/Lean/Server/Utils.olean", + "sha256": "c2a03554a131bed630c8b57d965b78c635062a6ac5d29086d801b76e9c3c1e5e" + }, + "Lean.Server.Watchdog": { + "relative_path": "lib/lean/Lean/Server/Watchdog.olean", + "sha256": "25bdfc1d26766745f8123b35795cf75cc03b3d067d7fa917d746a89972fa1081" + }, + "Lean.Structure": { + "relative_path": "lib/lean/Lean/Structure.olean", + "sha256": "1cce03c390b480c9ccfdc752f482f5772f9e8191a89ac2f92dbb371293edce08" + }, + "Lean.SubExpr": { + "relative_path": "lib/lean/Lean/SubExpr.olean", + "sha256": "56463ec2e047a75bc9582f7cba3698476c0595b80ad936524481c97edc7c57bb" + }, + "Lean.Syntax": { + "relative_path": "lib/lean/Lean/Syntax.olean", + "sha256": "1257d7730ef2a59134c6d3a66b812bd28464a93e906d80aa684118a2a2f7e41c" + }, + "Lean.ToExpr": { + "relative_path": "lib/lean/Lean/ToExpr.olean", + "sha256": "681106024aa58dff7c5dbea53ef9b5e01c166267413e6603fb59f7e6ba4705e4" + }, + "Lean.ToLevel": { + "relative_path": "lib/lean/Lean/ToLevel.olean", + "sha256": "0f1039c2e1e3a4e024294fe8827de0b83809ef22d6f95141a20f17bfd57010ed" + }, + "Lean.Util": { + "relative_path": "lib/lean/Lean/Util.olean", + "sha256": "b3804c0b6fd4187caaa395cdbf07b210634c36b5862e5b01e99a334894041ac5" + }, + "Lean.Util.CollectAxioms": { + "relative_path": "lib/lean/Lean/Util/CollectAxioms.olean", + "sha256": "9dd674224d00ea6e9044e05e9022d0997ed842b0eceee5157da199ea523614d3" + }, + "Lean.Util.CollectFVars": { + "relative_path": "lib/lean/Lean/Util/CollectFVars.olean", + "sha256": "03e91ed3ea63c86fa4a74f01eb026cba7a3c7a9a66e911f3420388bf0a24b06a" + }, + "Lean.Util.CollectLevelMVars": { + "relative_path": "lib/lean/Lean/Util/CollectLevelMVars.olean", + "sha256": "ee4f7731ff6e32e49c472ecc660fe70b7e8e28a9fe3e787d95968fc334cdafb9" + }, + "Lean.Util.CollectLevelParams": { + "relative_path": "lib/lean/Lean/Util/CollectLevelParams.olean", + "sha256": "f57df1551f35babfbd25cd4d786d36ca1c1e668a7dc733f1e86a7768a898c70e" + }, + "Lean.Util.CollectMVars": { + "relative_path": "lib/lean/Lean/Util/CollectMVars.olean", + "sha256": "1c5fc9f6e4a37382985419959a6a9e223763b770d78238e26e3b2029565d201e" + }, + "Lean.Util.Diff": { + "relative_path": "lib/lean/Lean/Util/Diff.olean", + "sha256": "348b407f6ab6b4cea1c17189e88ad4449669db50724e85bf333a7cd6eef01f8f" + }, + "Lean.Util.FVarSubset": { + "relative_path": "lib/lean/Lean/Util/FVarSubset.olean", + "sha256": "931302f6ee0fa3706536bf4c786d63c55903ee608fcfee3a7e62a884230b4689" + }, + "Lean.Util.FileSetupInfo": { + "relative_path": "lib/lean/Lean/Util/FileSetupInfo.olean", + "sha256": "fedeae0565096639cc7344c39c75dcd51760d451cf9e3bae3f67403fa3301420" + }, + "Lean.Util.FindExpr": { + "relative_path": "lib/lean/Lean/Util/FindExpr.olean", + "sha256": "fc9f82a261866735ac5f16c64903d5cd7ce354a5d559359f69e14c066299b82a" + }, + "Lean.Util.FindLevelMVar": { + "relative_path": "lib/lean/Lean/Util/FindLevelMVar.olean", + "sha256": "efa86d730a224bac9f9559414945fb8e4480adf9bd5c6f614bc386ccef4b79a8" + }, + "Lean.Util.FindMVar": { + "relative_path": "lib/lean/Lean/Util/FindMVar.olean", + "sha256": "f7c599d6b22db24fed3d4572b254ef1f625abbf242dc21a376a123913fbeaadd" + }, + "Lean.Util.FoldConsts": { + "relative_path": "lib/lean/Lean/Util/FoldConsts.olean", + "sha256": "30a5b555e3da24c6138cda39b0ce2fdd2898549424f3f48a5f0ad5a84a6ad024" + }, + "Lean.Util.ForEachExpr": { + "relative_path": "lib/lean/Lean/Util/ForEachExpr.olean", + "sha256": "f9b3a9c2bd938afe1ed5bfe2cdaac38da291c1f9cbc3ef00c6d70fe18c48b38c" + }, + "Lean.Util.ForEachExprWhere": { + "relative_path": "lib/lean/Lean/Util/ForEachExprWhere.olean", + "sha256": "0f66cc8ae514f42e32e37450023f5325c013a5f3b31cc00643b305ec2050a813" + }, + "Lean.Util.HasConstCache": { + "relative_path": "lib/lean/Lean/Util/HasConstCache.olean", + "sha256": "997838afe6cdc2068b866980bbc2d9571e08821ec262b3f96b5d182bda4d1e41" + }, + "Lean.Util.Heartbeats": { + "relative_path": "lib/lean/Lean/Util/Heartbeats.olean", + "sha256": "ef98dc435a31b539200931e89b2d3f08bd6e7f689e00ec3522ab1210b86e672d" + }, + "Lean.Util.InstantiateLevelParams": { + "relative_path": "lib/lean/Lean/Util/InstantiateLevelParams.olean", + "sha256": "f05e8a234de5794988814cab37b89a021d6e869311cd4fa372ab4f9ee2124424" + }, + "Lean.Util.LakePath": { + "relative_path": "lib/lean/Lean/Util/LakePath.olean", + "sha256": "dd00ea5edef5aeaf9d68948e3616d4de5052a4ac3e2acb67126898567f3fdb1b" + }, + "Lean.Util.LeanOptions": { + "relative_path": "lib/lean/Lean/Util/LeanOptions.olean", + "sha256": "036d4d32660acc69d0fc60938f15ea9ffa1edc7440340197d5d09dfbf7482e02" + }, + "Lean.Util.MonadBacktrack": { + "relative_path": "lib/lean/Lean/Util/MonadBacktrack.olean", + "sha256": "3a721336f768b1bd3d838101868b17bdcddb936acbe232601080cb47dae6bdef" + }, + "Lean.Util.MonadCache": { + "relative_path": "lib/lean/Lean/Util/MonadCache.olean", + "sha256": "a49bf6318c1fa4b7642ee350d0a0adfd5c9c30edfdbf5375bb08c27e89b9d09e" + }, + "Lean.Util.NumApps": { + "relative_path": "lib/lean/Lean/Util/NumApps.olean", + "sha256": "5e9a3b8f61219d6eb81d5e68ebf9783b3e653e6d2cad90d35d7fa1edaf48498d" + }, + "Lean.Util.NumObjs": { + "relative_path": "lib/lean/Lean/Util/NumObjs.olean", + "sha256": "1b6dcd0400b21b6478e0690faf12be333ac561dee8edf34fa9d940e0536d9c8d" + }, + "Lean.Util.OccursCheck": { + "relative_path": "lib/lean/Lean/Util/OccursCheck.olean", + "sha256": "2105d2cafdc97780ed80d0c21d96e3a96eb8c5b27c6f478ad8f511ff1d307a39" + }, + "Lean.Util.PPExt": { + "relative_path": "lib/lean/Lean/Util/PPExt.olean", + "sha256": "a5c502d22177658a419a532038b821f28cef4fa7a32e3c2544726ddd0b019c5e" + }, + "Lean.Util.Path": { + "relative_path": "lib/lean/Lean/Util/Path.olean", + "sha256": "75e708dc5859e0639e7eceae77d508a187db39ccb6cab080143e8dd26d4a0304" + }, + "Lean.Util.Paths": { + "relative_path": "lib/lean/Lean/Util/Paths.olean", + "sha256": "74142ed1f2181bb4102c8a0f6e41d41a4c658232937fc597f4e4b1c2a183b1bc" + }, + "Lean.Util.Profile": { + "relative_path": "lib/lean/Lean/Util/Profile.olean", + "sha256": "f23c4842d954d119e83de4dde14edb34981d6994cbeea4de9c2ae381f17bf831" + }, + "Lean.Util.Profiler": { + "relative_path": "lib/lean/Lean/Util/Profiler.olean", + "sha256": "1e9a3eec7c150b0e9ca1c785861eabb3f9a9c35a00d105c513439ec840a7ccbc" + }, + "Lean.Util.PtrSet": { + "relative_path": "lib/lean/Lean/Util/PtrSet.olean", + "sha256": "231e789db2045483e7600fec9903afba50dbba3e95c8c925982e2c1ea71b8a17" + }, + "Lean.Util.RecDepth": { + "relative_path": "lib/lean/Lean/Util/RecDepth.olean", + "sha256": "ea7a31d5424201f52482f7a9bf6de3ed5e0f8e741c131b78551fc6ac47b6b357" + }, + "Lean.Util.Recognizers": { + "relative_path": "lib/lean/Lean/Util/Recognizers.olean", + "sha256": "6ce3043ebd4aeb4bf7e43914580fc3fc414635d908d152ac393c283e07d0c2ce" + }, + "Lean.Util.ReplaceExpr": { + "relative_path": "lib/lean/Lean/Util/ReplaceExpr.olean", + "sha256": "aee2465ad5bf2bba0f52b8a4ea4b444990bcf68e15c7e32c387f31fb5a4606ec" + }, + "Lean.Util.ReplaceLevel": { + "relative_path": "lib/lean/Lean/Util/ReplaceLevel.olean", + "sha256": "bbdf8e6a5aa715de21a3edea51c9e0798e40fdffbd4896d15a3202d19e21bc21" + }, + "Lean.Util.SCC": { + "relative_path": "lib/lean/Lean/Util/SCC.olean", + "sha256": "f4ecd7303b846253b6aa74f4910f1c97089995e20ea654d78572898ea5ab764a" + }, + "Lean.Util.SafeExponentiation": { + "relative_path": "lib/lean/Lean/Util/SafeExponentiation.olean", + "sha256": "6ac2c719d74ffd8ec932fed7ea38541bb0bd64b1db68c15e143f1b31b7905a03" + }, + "Lean.Util.SearchPath": { + "relative_path": "lib/lean/Lean/Util/SearchPath.olean", + "sha256": "5c541f16a00ce65845346ff39f3e52602ba24873f9143b696ad31a35d0d0b174" + }, + "Lean.Util.ShareCommon": { + "relative_path": "lib/lean/Lean/Util/ShareCommon.olean", + "sha256": "041136336e252a66b1e09dbb0509423603f964469b9f41f34bb45cb47319683a" + }, + "Lean.Util.Sorry": { + "relative_path": "lib/lean/Lean/Util/Sorry.olean", + "sha256": "dc16c4717cb1b982328f48069d111d46ec937d63bf7648c94811c2ac7f8978a5" + }, + "Lean.Util.SortExprs": { + "relative_path": "lib/lean/Lean/Util/SortExprs.olean", + "sha256": "45a472f4dab7a0b1a22a2d5b07eac4e460c7a4471d49646f62e2d97d920faf6e" + }, + "Lean.Util.TestExtern": { + "relative_path": "lib/lean/Lean/Util/TestExtern.olean", + "sha256": "0c45aa686987702907d541dbe624dfb3b8c8389586d732fa05c9b86a53a96800" + }, + "Lean.Util.Trace": { + "relative_path": "lib/lean/Lean/Util/Trace.olean", + "sha256": "40e261ba920c89ca7a7573bfc699a3ac1e20983625025e2fc77a3aa8181a2c8f" + }, + "Lean.Widget": { + "relative_path": "lib/lean/Lean/Widget.olean", + "sha256": "82d3aaf72aaee748640ab3d5857f71623623455d4b4c7ac359f0f4e5e39a49f9" + }, + "Lean.Widget.Basic": { + "relative_path": "lib/lean/Lean/Widget/Basic.olean", + "sha256": "7b47ae225c065d669da84ca522e2dceb9a577e4bd7474d7377cf94d189a14ed9" + }, + "Lean.Widget.Diff": { + "relative_path": "lib/lean/Lean/Widget/Diff.olean", + "sha256": "6803e1c1d4d7de80fabd38cce68ecdabef3888f104d5b5bb17456a41a103ed6f" + }, + "Lean.Widget.InteractiveCode": { + "relative_path": "lib/lean/Lean/Widget/InteractiveCode.olean", + "sha256": "08dd8d5166eba1216188ec5a5b791c2e571805398fad6a4f0d1793026f063f54" + }, + "Lean.Widget.InteractiveDiagnostic": { + "relative_path": "lib/lean/Lean/Widget/InteractiveDiagnostic.olean", + "sha256": "a57b624487c0509b52919bf93ca49fd5006669cd87a28d7d1d6df05b7c121368" + }, + "Lean.Widget.InteractiveGoal": { + "relative_path": "lib/lean/Lean/Widget/InteractiveGoal.olean", + "sha256": "fe6f3299cefd00d81053c19c7a68a9140dd3c1199581807d18bc10212836b5b1" + }, + "Lean.Widget.TaggedText": { + "relative_path": "lib/lean/Lean/Widget/TaggedText.olean", + "sha256": "2231b307e81af9a860c445c61019110b50b2f7a147b20d4eff3a7aca896a495e" + }, + "Lean.Widget.Types": { + "relative_path": "lib/lean/Lean/Widget/Types.olean", + "sha256": "ec95be52006e362cdbab66493e159108d6b2803f7febb6f763d3e6ab58350a40" + }, + "Lean.Widget.UserWidget": { + "relative_path": "lib/lean/Lean/Widget/UserWidget.olean", + "sha256": "0e76215569ef9ba42148916c778a855b0eda47c384ffe95f40848401d3f7e77a" + }, + "Std": { + "relative_path": "lib/lean/Std.olean", + "sha256": "7d3771da25b893da62564bf8198487ff28f01af5cbd410be88d493a4921b2bb1" + }, + "Std.Classes.Ord": { + "relative_path": "lib/lean/Std/Classes/Ord.olean", + "sha256": "d951a4e6a043afe223eec3c1fc4ac05f4da95e923d7f9fa7438ccf1c4c5894e9" + }, + "Std.Data": { + "relative_path": "lib/lean/Std/Data.olean", + "sha256": "0c7214cfc515a6bd7d993a5a036a749d927911c61074e6f000b2f6e5c5e68437" + }, + "Std.Data.DHashMap": { + "relative_path": "lib/lean/Std/Data/DHashMap.olean", + "sha256": "82829a319d1dbc479d69cbeded2541fb6d4bea621843bcfb621dcddf66e3df4a" + }, + "Std.Data.DHashMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/DHashMap/AdditionalOperations.olean", + "sha256": "dcda48b215964eeb7adfdd6d8c898750cfdde669285b7e53559e844747be2e4f" + }, + "Std.Data.DHashMap.Basic": { + "relative_path": "lib/lean/Std/Data/DHashMap/Basic.olean", + "sha256": "3edd8593c538aa619f7a6a49b1201f895b2e195732067e9804cd1ec746ae0230" + }, + "Std.Data.DHashMap.Internal.AssocList.Basic": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Basic.olean", + "sha256": "cde6580d4017820217ba306c2850560e6c3820a22675b795bab7deee58fae39a" + }, + "Std.Data.DHashMap.Internal.AssocList.Lemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.olean", + "sha256": "89bb1625f83532972c2508e241727bd158ed8630437449d6dfb2409004029cca" + }, + "Std.Data.DHashMap.Internal.Defs": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Defs.olean", + "sha256": "b6789918a75b94e20a471fc1249196389b61a7bca005cb6e11868b9b2e0b2050" + }, + "Std.Data.DHashMap.Internal.HashesTo": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/HashesTo.olean", + "sha256": "df5a76c22a9d30d6067466a54454ffafb1d7a268ff2327e10d274d4b86bcb787" + }, + "Std.Data.DHashMap.Internal.Index": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Index.olean", + "sha256": "ca4d3761d5291eccc1f8238dafbe210fa5666c54a0a42c3e9b51acdcbe9d4900" + }, + "Std.Data.DHashMap.Internal.Model": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Model.olean", + "sha256": "dd3b5266f90bdc5e4cc8c5e9c1b65222671aaa830a5a23508f9fdb00fa6111c3" + }, + "Std.Data.DHashMap.Internal.Raw": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Raw.olean", + "sha256": "ab20c7d8f702c86de6cce3e18141f1297dea8d51a579460b0ddab9e278daf908" + }, + "Std.Data.DHashMap.Internal.RawLemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/RawLemmas.olean", + "sha256": "aa891b7b6476ead8295065dcd7df85e16c40e95a8a48c433d1e0c6ff8f58e9a7" + }, + "Std.Data.DHashMap.Internal.WF": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/WF.olean", + "sha256": "0d02c631912fd443890dd882c9035af450a64ded829c5613e29c6ad6d8690538" + }, + "Std.Data.DHashMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Lemmas.olean", + "sha256": "f5191f02349eb72c1ddb45074f9239912d9cd008a48a6cbabd76b2469d28d197" + }, + "Std.Data.DHashMap.Raw": { + "relative_path": "lib/lean/Std/Data/DHashMap/Raw.olean", + "sha256": "5ff8a7568a967e563bba428926cc128806c61ef2ecce021358984a45cff4c308" + }, + "Std.Data.DHashMap.RawDef": { + "relative_path": "lib/lean/Std/Data/DHashMap/RawDef.olean", + "sha256": "98e9e12f08790541143b32cfdaec3d0289209b1e770774dc01345116a7dddca4" + }, + "Std.Data.DHashMap.RawLemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/RawLemmas.olean", + "sha256": "514c964fac6f063724169db30add357a674ca243957dfa221e30430c26f06c92" + }, + "Std.Data.DTreeMap": { + "relative_path": "lib/lean/Std/Data/DTreeMap.olean", + "sha256": "51e3386cf7ba0a9f270c3a6d44af2ef5f6bac8fcffe8458cb7d3bba2edf610aa" + }, + "Std.Data.DTreeMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/DTreeMap/AdditionalOperations.olean", + "sha256": "a20b5c57a0db704748a2e2926dfa4d2cf1e4ddaefcc2245688970941c5ca8429" + }, + "Std.Data.DTreeMap.Basic": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Basic.olean", + "sha256": "26808eeb3d7d1e129af3a70fe13001b79dc74b18c7b406cb1373c7de98f62f56" + }, + "Std.Data.DTreeMap.Internal.Balanced": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Balanced.olean", + "sha256": "485264c582ccaaf76b6796dd881ccd1f6f61012f5d0c722fde5bd9a7b4310c70" + }, + "Std.Data.DTreeMap.Internal.Balancing": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Balancing.olean", + "sha256": "5263f1223026803115af0abbeeffdea7754796f215e6713aefc40c839b8353c1" + }, + "Std.Data.DTreeMap.Internal.Cell": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Cell.olean", + "sha256": "16fadb10f9bf8b6f4f20ec627775bdb827ff1f12c66b8e5f97c7e14b4a63ce98" + }, + "Std.Data.DTreeMap.Internal.Def": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Def.olean", + "sha256": "ad1d1e858fb304c03404a3003afefa2ab63634f240352448dbbe000fbc280ae7" + }, + "Std.Data.DTreeMap.Internal.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Lemmas.olean", + "sha256": "86f93dba7c263b8817d9a6e568d2a298b223b1dcf7a3bf63a21e04485d1e702e" + }, + "Std.Data.DTreeMap.Internal.Model": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Model.olean", + "sha256": "190a424ea72373859e33b93057f74fddfff1901c99020758c3b2a071893edcca" + }, + "Std.Data.DTreeMap.Internal.Operations": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Operations.olean", + "sha256": "02e3f14395f2e036d817076b3e901b7d186bd39c8b9e7204a1684faac1b5eaca" + }, + "Std.Data.DTreeMap.Internal.Ordered": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Ordered.olean", + "sha256": "bfd736cf4717c6dfd91e4764c030a2e35d7d80f24532ceccbb56924be30d3603" + }, + "Std.Data.DTreeMap.Internal.Queries": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Queries.olean", + "sha256": "4fb2bc063203c87f9db29252321a80602d0a7265647778abc9d22aaba5acbee7" + }, + "Std.Data.DTreeMap.Internal.WF.Defs": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Defs.olean", + "sha256": "899b439766bf2c13fba7b5ebfa6da9110b2e9f6e9ad9125c721d339332792432" + }, + "Std.Data.DTreeMap.Internal.WF.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.olean", + "sha256": "b6660199d8eaf0aaa0227cc92ef439c43914ff5f193983cb236d761212481a2a" + }, + "Std.Data.DTreeMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Lemmas.olean", + "sha256": "8f13b8ea4484f0112ac26021f999437da815203047e8d6dd398b3460616466bb" + }, + "Std.Data.DTreeMap.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Raw/Basic.olean", + "sha256": "d7ac0f19bdbd8fc3fbdeb86e07d5359234da8e0ead67247fb552613579747f6c" + }, + "Std.Data.HashMap": { + "relative_path": "lib/lean/Std/Data/HashMap.olean", + "sha256": "99aff9518169b47e1e93af220fb0526ff2a5ecaf538ff1bdd2962b6f2c8d4758" + }, + "Std.Data.HashMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/HashMap/AdditionalOperations.olean", + "sha256": "f7122016e852683cbe4b78252a5a0d334e31d8c583634068600988194a135753" + }, + "Std.Data.HashMap.Basic": { + "relative_path": "lib/lean/Std/Data/HashMap/Basic.olean", + "sha256": "6f76031eeeaa6d43db6e9c3a77c12f7811a80ac7d92b1538bd1b03c99e0588f6" + }, + "Std.Data.HashMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/HashMap/Lemmas.olean", + "sha256": "13da5f44c528a875968ebcab85fafb5cfc854b7f54fd4880ae6fbec2c8dd70d6" + }, + "Std.Data.HashMap.Raw": { + "relative_path": "lib/lean/Std/Data/HashMap/Raw.olean", + "sha256": "e22fdbb83c3274c85d0a292a3810c6408d134cf0d5e8bc0329f50777aee3e3f3" + }, + "Std.Data.HashMap.RawLemmas": { + "relative_path": "lib/lean/Std/Data/HashMap/RawLemmas.olean", + "sha256": "0a3c4d3b8e8d5ab3006148f6e227e5482da7199f8865c0c8dc762d07a13c71a8" + }, + "Std.Data.HashSet": { + "relative_path": "lib/lean/Std/Data/HashSet.olean", + "sha256": "ae45358a15acbf4ac5609305ab80d9ca42fa22cb4589f3c48c2a94a507250451" + }, + "Std.Data.HashSet.Basic": { + "relative_path": "lib/lean/Std/Data/HashSet/Basic.olean", + "sha256": "8bae54c3695a9aa1f51b76043d32ebbae9123b1a155605c54c1be2a899ce3385" + }, + "Std.Data.HashSet.Lemmas": { + "relative_path": "lib/lean/Std/Data/HashSet/Lemmas.olean", + "sha256": "29883ee4a5a8aceeef42dd000f1a3d682416b3668289b05afbb86cf3dbe7ed72" + }, + "Std.Data.HashSet.Raw": { + "relative_path": "lib/lean/Std/Data/HashSet/Raw.olean", + "sha256": "dc892a38a4976c064458b561027640cb3343c9661141c532c465f24bb635271d" + }, + "Std.Data.HashSet.RawLemmas": { + "relative_path": "lib/lean/Std/Data/HashSet/RawLemmas.olean", + "sha256": "ad52a319fb705c08ffd691126d42ee63e0e6a6caeb828114828cc2fe466f8db9" + }, + "Std.Data.Internal.Cut": { + "relative_path": "lib/lean/Std/Data/Internal/Cut.olean", + "sha256": "16e746f9da7b0e74567b1656a7e3f99cafc699acc54faed11bbe17a02d801060" + }, + "Std.Data.Internal.List.Associative": { + "relative_path": "lib/lean/Std/Data/Internal/List/Associative.olean", + "sha256": "fec662ce7c583a3d835d612b39ec478a6153c06e3b7de30a537cf6895f5bb093" + }, + "Std.Data.Internal.List.Defs": { + "relative_path": "lib/lean/Std/Data/Internal/List/Defs.olean", + "sha256": "56e8ec040898820fa1f1b9d807be6c96e4c44812b61c37b29ba4eb92199dbbc4" + }, + "Std.Data.TreeMap": { + "relative_path": "lib/lean/Std/Data/TreeMap.olean", + "sha256": "a1acd79ea550bcbeb8803a663d203d65c2ec5f3c528e1d3b20e6d84bba1f5818" + }, + "Std.Data.TreeMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/TreeMap/AdditionalOperations.olean", + "sha256": "7ff677628c427286ffa273bb5e733ba2b3c400ba4ac199377d8f354740bd90d5" + }, + "Std.Data.TreeMap.Basic": { + "relative_path": "lib/lean/Std/Data/TreeMap/Basic.olean", + "sha256": "01d1578d10e52b69cfa9a2ebc0dbbb16dd36a786deee2bdf44129b2672f67755" + }, + "Std.Data.TreeMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/TreeMap/Lemmas.olean", + "sha256": "c6b1f9d219326bf24700910e14066001120a278f007001bbf2a32dedd1af4006" + }, + "Std.Data.TreeMap.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/TreeMap/Raw/Basic.olean", + "sha256": "bc2fb5d7aa288ceb2d373f3c6a66c016a439cd1eb5560ba2a641e835064c833e" + }, + "Std.Data.TreeSet": { + "relative_path": "lib/lean/Std/Data/TreeSet.olean", + "sha256": "14078e4b78360b5431a4232dc911486455591bff1a3fad55f9155ae8c2ad7cac" + }, + "Std.Data.TreeSet.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/TreeSet/AdditionalOperations.olean", + "sha256": "86a8774587ec420050092ce6ba115aa9d379c59b491f55c815c062fdff15ce73" + }, + "Std.Data.TreeSet.Basic": { + "relative_path": "lib/lean/Std/Data/TreeSet/Basic.olean", + "sha256": "8f725039367c3acfe7a9de41011ce1bf66cb375fb16a0b4468d414c2f0ed5fc6" + }, + "Std.Data.TreeSet.Lemmas": { + "relative_path": "lib/lean/Std/Data/TreeSet/Lemmas.olean", + "sha256": "c436c982509e245de849ae7ca0a437b7f08eed26cd7a3eccc926763acd3fe9fe" + }, + "Std.Data.TreeSet.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/TreeSet/Raw/Basic.olean", + "sha256": "e970f9894439ef66418424f9d769c9e76de5ed0a6443c90dd821b482d715d015" + }, + "Std.Internal": { + "relative_path": "lib/lean/Std/Internal.olean", + "sha256": "450df0e4fd6e36bd632bccad2663e04b615dbba865e59de53815dd54bc5d3c1f" + }, + "Std.Internal.Async": { + "relative_path": "lib/lean/Std/Internal/Async.olean", + "sha256": "01ffdfd1f0410911338f8ef8b7e5f403d875b1a38ed01eac1953cd9c1659e3eb" + }, + "Std.Internal.Async.Basic": { + "relative_path": "lib/lean/Std/Internal/Async/Basic.olean", + "sha256": "77e5e714a1a50a1c66d738574d61b94729fa505d928f4041b479220c35f926d2" + }, + "Std.Internal.Async.TCP": { + "relative_path": "lib/lean/Std/Internal/Async/TCP.olean", + "sha256": "b8d4d89acab2bbb45c8f0ae41f0d43a9d1978efdbbf3cce9d21a8adbe977fbf2" + }, + "Std.Internal.Async.Timer": { + "relative_path": "lib/lean/Std/Internal/Async/Timer.olean", + "sha256": "df2a28402222a5529fe6c5d506b96d8b1a11a9a5722456590e77be97fe7bd59f" + }, + "Std.Internal.Async.UDP": { + "relative_path": "lib/lean/Std/Internal/Async/UDP.olean", + "sha256": "42aaaef54fd0324c3160d18901df6ab67d12c1392a5f7f79764e4b8ccdabef84" + }, + "Std.Internal.Parsec": { + "relative_path": "lib/lean/Std/Internal/Parsec.olean", + "sha256": "847cdbecf06faf5fc1ec0a8edbda87e56cae864215c3e5b0794e4487e52991e5" + }, + "Std.Internal.Parsec.Basic": { + "relative_path": "lib/lean/Std/Internal/Parsec/Basic.olean", + "sha256": "5043a60429010c81f150397f937633e38e59a4ebb0fedd362a3c4326d4c9e70c" + }, + "Std.Internal.Parsec.ByteArray": { + "relative_path": "lib/lean/Std/Internal/Parsec/ByteArray.olean", + "sha256": "b83f1320328c2ad431534ac41512842f4d99059c8ffce50cfad5c323f5d05bcb" + }, + "Std.Internal.Parsec.String": { + "relative_path": "lib/lean/Std/Internal/Parsec/String.olean", + "sha256": "d8fb53b268a2d7ca6b26a14028a6e2a396063d3c747373aca64f18bdafbcdd82" + }, + "Std.Internal.Rat": { + "relative_path": "lib/lean/Std/Internal/Rat.olean", + "sha256": "63e1219fe06b26b0022abcebc49b641a8726d1ffcb43650b6afcb61af71ef85e" + }, + "Std.Internal.UV": { + "relative_path": "lib/lean/Std/Internal/UV.olean", + "sha256": "510f7cfab3bf9547fe3bce0dd31453b8521ed3b7b25beeb16ee88bb088c90e60" + }, + "Std.Internal.UV.Loop": { + "relative_path": "lib/lean/Std/Internal/UV/Loop.olean", + "sha256": "732dc39b26fbc6027819191475f9aade211b5995be9036bf0babd80d2740d09e" + }, + "Std.Internal.UV.TCP": { + "relative_path": "lib/lean/Std/Internal/UV/TCP.olean", + "sha256": "dadd785a07060659ba22f37fcb6e17a06af3b6140d200e7d8f223ae7aaf928ad" + }, + "Std.Internal.UV.Timer": { + "relative_path": "lib/lean/Std/Internal/UV/Timer.olean", + "sha256": "57cee1e20bf5d037bcf6afe9720488ee00720e2deb2ce05d0445d4e097fc27b1" + }, + "Std.Internal.UV.UDP": { + "relative_path": "lib/lean/Std/Internal/UV/UDP.olean", + "sha256": "29d41d16510671c81a1df5b46e75f8c61c0ecce2ee5b35e53737bdc724022b2e" + }, + "Std.Net": { + "relative_path": "lib/lean/Std/Net.olean", + "sha256": "4c3e86bee81a4336a0aa64a3be9467a20b8b738bd1a8924ee4df82b980a0e4a2" + }, + "Std.Net.Addr": { + "relative_path": "lib/lean/Std/Net/Addr.olean", + "sha256": "21a68252d88ccc4e33691b2cab7aef5cc7cc8881c4e7a00e2154c4db8635492d" + }, + "Std.Sat": { + "relative_path": "lib/lean/Std/Sat.olean", + "sha256": "fcc29fb616396ddc2d3047d9b5c2f8dd3ad6239d727e06edfa2273e11f22109c" + }, + "Std.Sat.AIG": { + "relative_path": "lib/lean/Std/Sat/AIG.olean", + "sha256": "7c6aea2cf4f55d3ea5b3b4ae186869fcd416cb24fc5b1c797bf2aa511ced7207" + }, + "Std.Sat.AIG.Basic": { + "relative_path": "lib/lean/Std/Sat/AIG/Basic.olean", + "sha256": "97590c68ccbef54da03f6ea927368d999b560f594840a2c2c3899e52602a2a19" + }, + "Std.Sat.AIG.CNF": { + "relative_path": "lib/lean/Std/Sat/AIG/CNF.olean", + "sha256": "38e7324f561c93510b5b42466fc3b60be8372a46e0b872a45678fd6dc40c8495" + }, + "Std.Sat.AIG.Cached": { + "relative_path": "lib/lean/Std/Sat/AIG/Cached.olean", + "sha256": "f9b8e7536aaa9f2663fb19cbfddd1da6c0c9d1035b79ed5f71acea3ed76a913f" + }, + "Std.Sat.AIG.CachedGates": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedGates.olean", + "sha256": "a9fba0492584b3e3e537f181e626be94d5ff4d4f7cdfb6193d0ebfa59619fb03" + }, + "Std.Sat.AIG.CachedGatesLemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedGatesLemmas.olean", + "sha256": "e7637f2f0f2df05851138dc94f305c976aca8fbd121f648afae1b1be75edf072" + }, + "Std.Sat.AIG.CachedLemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedLemmas.olean", + "sha256": "4e8c65e9bc960950ea123ee30c9434b1e7a31955db5c6b118b5f6d1bf91b4151" + }, + "Std.Sat.AIG.If": { + "relative_path": "lib/lean/Std/Sat/AIG/If.olean", + "sha256": "0a976606263c24d96f678d34322b1172ee3ae1c1f50c9bc25274411b99ddbb21" + }, + "Std.Sat.AIG.LawfulOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/LawfulOperator.olean", + "sha256": "c8467c1aee8523a9b728ccf79988145304cada06f1da7eb80324db331aec8728" + }, + "Std.Sat.AIG.LawfulVecOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/LawfulVecOperator.olean", + "sha256": "2bcfabf0755288b3c3099a16e615e0e7e474c9b48e705ebee28137a46c4c6768" + }, + "Std.Sat.AIG.Lemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/Lemmas.olean", + "sha256": "0056f8de120614c48889fe5157b0fa5eb4e5caa87c1300a46d6f412268baf65d" + }, + "Std.Sat.AIG.RefVec": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVec.olean", + "sha256": "e8de7999a97a5390370aec10715a77d3abaf292a7df37a584c06e706458284ae" + }, + "Std.Sat.AIG.RefVecOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator.olean", + "sha256": "c07b62713579424613487ed5f40318b44cd5a30036959d23e9c7a39256c9474f" + }, + "Std.Sat.AIG.RefVecOperator.Fold": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Fold.olean", + "sha256": "8c65d0c2a25e424866314efd53a4edc08c2cd9da55edb76034538969fa3db5bc" + }, + "Std.Sat.AIG.RefVecOperator.Map": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Map.olean", + "sha256": "569cee3ddeb7b1b314354d0f051052bc4d21919d3948c06eeaba5da15f9dac96" + }, + "Std.Sat.AIG.RefVecOperator.Zip": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Zip.olean", + "sha256": "94244a0a8f0ce753f93b64831b56577cd9b8d68f9131b278281b77a3f2d43d44" + }, + "Std.Sat.AIG.Relabel": { + "relative_path": "lib/lean/Std/Sat/AIG/Relabel.olean", + "sha256": "fbdc72b958646b6206f8fd36cac01472e075dc69705f33947bbbef6614b6aa8b" + }, + "Std.Sat.AIG.RelabelNat": { + "relative_path": "lib/lean/Std/Sat/AIG/RelabelNat.olean", + "sha256": "8d7e0ea32786d8ce69c8605df88c666dbf8dee641c7945fde40e302ce7051a9d" + }, + "Std.Sat.CNF": { + "relative_path": "lib/lean/Std/Sat/CNF.olean", + "sha256": "a7ad1ae81e0305e03e2b6f3827101cde4cf4da0b64a59b3a25c038c4661ddc77" + }, + "Std.Sat.CNF.Basic": { + "relative_path": "lib/lean/Std/Sat/CNF/Basic.olean", + "sha256": "9fd3c6545ed9a1cb8b606df1749d7e40eb4eac6932fd19ad0efbbaaef98534d4" + }, + "Std.Sat.CNF.Dimacs": { + "relative_path": "lib/lean/Std/Sat/CNF/Dimacs.olean", + "sha256": "d35723222970cd0c95eccee2d1c8d94aef51ab955c1b8f35eb024fc395f664b4" + }, + "Std.Sat.CNF.Literal": { + "relative_path": "lib/lean/Std/Sat/CNF/Literal.olean", + "sha256": "86f2a80fe2c28b8e831989e13154f772a51fe820bca3ea61c5a542a56b0eef6d" + }, + "Std.Sat.CNF.Relabel": { + "relative_path": "lib/lean/Std/Sat/CNF/Relabel.olean", + "sha256": "e9bb76081b5ecf50ee4b6dd88e99f9cf405dc77574772c8645fd5f43d4310ec3" + }, + "Std.Sat.CNF.RelabelFin": { + "relative_path": "lib/lean/Std/Sat/CNF/RelabelFin.olean", + "sha256": "5b23bd94880be12c59a33437f57c82873234d547a0085a29c6dc4ca37f304ab2" + }, + "Std.Sync": { + "relative_path": "lib/lean/Std/Sync.olean", + "sha256": "6b122caecb73d049b18ea82b184696b04898758dea48f62c7e8b0ec17068c34f" + }, + "Std.Sync.Barrier": { + "relative_path": "lib/lean/Std/Sync/Barrier.olean", + "sha256": "0865e927b2d5c74eb1e762ef6043b19db015a3f7a16997392bdbe3405616c9e6" + }, + "Std.Sync.Basic": { + "relative_path": "lib/lean/Std/Sync/Basic.olean", + "sha256": "0ab37aae226de3c3c249e48eb99348220fd9239db043e8e70b00491ca7df6ffb" + }, + "Std.Sync.Channel": { + "relative_path": "lib/lean/Std/Sync/Channel.olean", + "sha256": "d263a7b5e81f7d062701d56c2f2940ec728e0b45d42ae29ac7ef5ad174b17a0f" + }, + "Std.Sync.Mutex": { + "relative_path": "lib/lean/Std/Sync/Mutex.olean", + "sha256": "28b1da9b8ad2e7873573ef3a394c20fbb1483b145dea927e22ae760913dfd30c" + }, + "Std.Sync.RecursiveMutex": { + "relative_path": "lib/lean/Std/Sync/RecursiveMutex.olean", + "sha256": "e270bb327da588a077b986c6683149f93c99ed2e43f2b80cdc79bf3255118fe5" + }, + "Std.Tactic": { + "relative_path": "lib/lean/Std/Tactic.olean", + "sha256": "bc4cb70f826910d0d63d5bb519966d715681e8fe8fb73913796d9c51c8530d7d" + }, + "Std.Tactic.BVDecide": { + "relative_path": "lib/lean/Std/Tactic/BVDecide.olean", + "sha256": "ec2db6253a2c5adbe13b53fdf97893e62022706a3a1604ade21af796ae949a17" + }, + "Std.Tactic.BVDecide.Bitblast": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast.olean", + "sha256": "faef1612ce3f38d3fa7978cf6b303d9876bbd43837dab7bfc0d7df30a42a1f86" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.olean", + "sha256": "36c4f0fd074cd62290da4cd5d0dd25b253108e7b37927836a2a68e24cbc62611" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.olean", + "sha256": "3fbf55b92e7fa7459b5626803a5c28693f10ae22bcc07dd0bbd5f9e52ddd5fc4" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.olean", + "sha256": "dc870f512d9db277c5e04837974578471b7aa8b6d7cd20c2e349c9f55776fde1" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.olean", + "sha256": "2bc70c17d6a23ed6d2b67e0fa0c46a2cde4b41fa6aec824dc64f609a81f8076b" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.olean", + "sha256": "28690113394104f6b0bf446e71254522b38e370ad8b4c48d2643c3c251f117c4" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.olean", + "sha256": "f831b1544b66b6c04562548d8ee3cd406faed9171e989001d235ca22489d93de" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.olean", + "sha256": "00399f76c92cefb3439614ef294998f337e72995b6279c7f3f57be5a182f3952" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.olean", + "sha256": "9fc172f017a8e08b3d373edb60be3aba9e3d82854acee27bb757e2052b7a073f" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.olean", + "sha256": "ba59db26788faeb05b026dd06ba5ddb8b39cb9169110413fa6ad5d65a1782f43" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.olean", + "sha256": "296f54c53ddf18f21dd6dbc6e279ba7256b944e35ed130570288d2fbc1bbafd3" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.olean", + "sha256": "4391a259589f6be7008648b4ab9eef743dc2b9a74f0f7dd4d631d534b8811e17" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.olean", + "sha256": "c87ee1a5d918eeda72930bbcf4889d9402a09bfe286b25012b06efac778dafbf" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.olean", + "sha256": "69116d9ffc41a4f37932d8cb3b4cea6592b9bda6f583df045b0f30ae0ec4a878" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.olean", + "sha256": "1c3439af37c32110c822bfee7afdf8b82289219f223e4475a61a2930876c270d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.olean", + "sha256": "bdae571ecb63fcd2e404c549d0233645f1d49daa257b854c03fdc672b11f25fe" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.olean", + "sha256": "6be36fe5e846df460b9cafdce7ce00525a16032b0f9957ef269429e4bc3235ce" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.olean", + "sha256": "2af3d46c89c1184b87d0499f08ae1364ede6b4d45a682ecc84a646c6ff37b590" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.olean", + "sha256": "59df5f0bdf0ab63f1d3a70c1ec428b51cd4d272aedd17ff6e69a47c8043eeb90" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.olean", + "sha256": "1c55bdc3550f4476aad8e2aabd64211d69c8993514758e2af3cc2251769b138e" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.olean", + "sha256": "f13b326a06e1000c0515520d0f4899e1aff23420f0e0e6ac5bba48a7a2061741" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.olean", + "sha256": "102946d64852967c3f451a662c10e0a548bec046e621e551b7dc467e4a0a2d7e" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.olean", + "sha256": "5f58293f58319935148d7a2bc68ad221ce9f5af0083862d72aece51381358100" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.olean", + "sha256": "5d0b577707c12577db272d62533ff29b2c37eca1ea425df4aaf104e74082ce1d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.olean", + "sha256": "0557dd76c0b555d978d97d7f04bc178ebb786d428871e4dd3cd73445f8bd2c39" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.olean", + "sha256": "81ba89dd877e8f5ecb4d79795d720bff671a1c226354759b28fab162f38e46ff" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.olean", + "sha256": "ebc829c16a69ba4601c7173f03eec5532020c0cff7ae92cd6dbcefd0368c2697" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.olean", + "sha256": "a4303ebf7a2e9d22270c2838e6240c06b563518adb9d4137349db1777b96ba86" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.olean", + "sha256": "3a8c2f39f7bf1f389bbd88e0e960d34ecf4b7af474a15d3669a397fe63a3b687" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.olean", + "sha256": "d67ad63ce049fe122cf9772ed2782555c6616ac326f67426e153f6cd5f5f31ea" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.olean", + "sha256": "308ad2bec762bc6ba6dd20c8a59466369dff6f12baed0014502ceb9af81f9128" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.olean", + "sha256": "c594d47b6dd7831dc6fbf18f337e4beb8cc317596d4da513c74cdd590b2aaa82" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.olean", + "sha256": "0e83560f33741e683d83de2c88d3b9bea126b818d4f9b947b6e2e60f3273793a" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.olean", + "sha256": "f4afff7bfa61967afcddcef49102e8aa6abfb46ac719f45fae9b2929995939df" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.olean", + "sha256": "57f9283128ba0708949930c0919ecadc22ec7b9d7e6b2dcdd7fad92a736afe0d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.olean", + "sha256": "35d396442771affa7630a0347396755620f9d042e8d489514dbefa2e5f3bd3ef" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.olean", + "sha256": "61ab83020b62ecea43b39fb36d24b2c6264f101c300bc53a020e29ac5cf23202" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.olean", + "sha256": "561125bbfaf3f343d17e25d37d77e43cfd0eaf6e21e0017cc9112929162d6628" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.olean", + "sha256": "cc8b989993b821ea578bb842b8da6c80522df6826b6d01238ca5adb568e449ac" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.olean", + "sha256": "d3072d202bf75c36371af08a4299d2982ad51392353d92d5011357964e3cd384" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.olean", + "sha256": "2be5439ac28922644312c8f8299059f81e58c79741d3a681a8a14a83457649ab" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.olean", + "sha256": "5b894fa82377d826b231e52d38987bf71fc1b10a92a7955fd18d9e5e5ebfe7ec" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.olean", + "sha256": "b2ac78762a87a6575421fda19f6576adf93e93f0b1af4b0ce49f55b8e9064463" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.olean", + "sha256": "0c5587d74b82923fd948c50d3da937bab12b86ec827d5e560c82b35bfa5c68fa" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.olean", + "sha256": "b95d38b7d0aabf70cb06123400e6ba0b94fd6073228b0eb5f55ab97d4428938a" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.olean", + "sha256": "789048c3011f067a8b8fba24630807fa03ce445f9e3dfac8c3528a4456603265" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.olean", + "sha256": "3dcc31a71f38e23ac8977a6e457302b32f5bcebde968012f3c33719e6b9c14f3" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.olean", + "sha256": "b5f8825d43310fb7f7333af20149f3064337396bafef7011d8af55c7f90380a5" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.olean", + "sha256": "8d9ff31e861a653c4998376235a1bfd1dcf760f05e1500f9867180cefd020d8b" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.olean", + "sha256": "10d1d3835811dde10bb29ad96b6c897780d8560198b0d04f28d1c3e4f4be1205" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.olean", + "sha256": "41ca8e8480c53c66991bf6dd267aa6bcd8d7c347942dec93d11b85f8d7224555" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.olean", + "sha256": "b2d68c645229bcfff4c1cb5d536e6acc7cb924ee954f9632198d5039280cd446" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.olean", + "sha256": "76828daa75f4568048da7ae525f1da9927112b9ea96ec22385387e2dcc0d1cbe" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.olean", + "sha256": "1a87afbf4654899ff46aed23db3f6ee24775b3113f551d4b1fb1e4e055b4968b" + }, + "Std.Tactic.BVDecide.Bitblast.BoolExpr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.olean", + "sha256": "3ab631e587fb4f4a5fc155f91d705d3ac544f98c75b22313db962ae0fcd9ba26" + }, + "Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.olean", + "sha256": "d441ce6550ac5d66fa7fed9d2f1b2e6a7207a0aa82d82da4ea372b2a4fad5526" + }, + "Std.Tactic.BVDecide.LRAT": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT.olean", + "sha256": "d355212d6f59c522d94e3c3dd34e3a02d74584f21270d3c75fd0f7b0fc1e6b23" + }, + "Std.Tactic.BVDecide.LRAT.Actions": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Actions.olean", + "sha256": "0077323c22e78b14dd46684d812da596c363a8f835ab47d9b7b429edcaf77c6f" + }, + "Std.Tactic.BVDecide.LRAT.Checker": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Checker.olean", + "sha256": "24cd2c42a4f2f34ecb83b2214194c9c808c7cc2ae49763f785d66911fb791e64" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Actions": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.olean", + "sha256": "6a8d16b5f258b9da457a8dae2729cf9cc8184ae3770c62c7767b60610d12cbf2" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Assignment": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.olean", + "sha256": "1dc4cf78bf8dd9093f22e8fb31fc2585a676096e1f92d8a169853e8c32e27868" + }, + "Std.Tactic.BVDecide.LRAT.Internal.CNF": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.olean", + "sha256": "5b09536fadc7ad28c0597d86a2926cc69397fbf93011a53ec07f3bc5d8144527" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Clause": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.olean", + "sha256": "c0ee4492b32ab35324ba3aa234288a517bbfd1a057b55a12b5587579dc8de5e4" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Convert": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.olean", + "sha256": "644f9516699727499c6bbf434dc411c7e32be39727c27df9fcf4ac4bc7885dfd" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Entails": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.olean", + "sha256": "555bd01a87e35f742a6784327cb0e15caa4b4589fdcb23b7d156612c8359aa60" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.olean", + "sha256": "e402782d59c498b9098addaf51b65c2a1f76015a3626d11ab150c7f8e4525e3c" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Class": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.olean", + "sha256": "61faf33007eb81ff1ba8c12c4829d6b8353b52580d1ae32216c5acce24117930" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.olean", + "sha256": "d8d956c48977e92718e15f51f3ed0e37b2523e84129f48c93d738a5ecc73e598" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.olean", + "sha256": "02dc2826a248aba00b4ff538bf73d1e84a1d26cb6bd86878e9aeaf96911578ea" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.olean", + "sha256": "326b363db75185b4e385f6d5ed25e3bc52249695cd47e96f7291b2befc17d99d" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.olean", + "sha256": "c8ae044e3f0cbfbdd16a5c8776c5bb505b8edecd7caa7227ac3e268f8e5a813b" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.olean", + "sha256": "f4639e7f4ce1257677cb3ef954622a378c51facaa49d1c2033d655a0429854ee" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.olean", + "sha256": "3db7edc84442cd86d9688f0259a59868e76ed0759f2d86dd35da5b8e928fecb5" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.olean", + "sha256": "7584cffd13ae359e9c7ef8edaea45c6d0233fbdcee5d80ee57aa9ac5284af5ce" + }, + "Std.Tactic.BVDecide.LRAT.Internal.LRATChecker": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.olean", + "sha256": "adad26830176d3fbb2cbd64c83197f5083e196b2a2651ee8d7194512724770da" + }, + "Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.olean", + "sha256": "b21dfacd5f2e5488e49885bfcf7de9deeb429a3c12a9a5d595f9f118372e8f90" + }, + "Std.Tactic.BVDecide.LRAT.Internal.PosFin": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.olean", + "sha256": "c9064ca9acae028a144600c48c49583991419d743274fc91d3bc6033e5f647a5" + }, + "Std.Tactic.BVDecide.LRAT.Parser": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Parser.olean", + "sha256": "99c91ddf2e3209427989057505c6db8ae009b0b66473add1123091e82eae22d5" + }, + "Std.Tactic.BVDecide.Normalize": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize.olean", + "sha256": "5a32966bb5d1d044ebbfa16701971c19613410077471fd78907932d23ac9d896" + }, + "Std.Tactic.BVDecide.Normalize.BitVec": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/BitVec.olean", + "sha256": "9a5419dace60a2336218c9900ccc2ba5b1740ee3ad3395204c1db96e2ee1265a" + }, + "Std.Tactic.BVDecide.Normalize.Bool": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Bool.olean", + "sha256": "e4a7ad5bb1aa46632d4f53c2e534df650adbab5d2299ab05f9357bf814568c02" + }, + "Std.Tactic.BVDecide.Normalize.Canonicalize": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.olean", + "sha256": "42efde7852aa32bfb49a2096a017f1acc3de2be1843f9a766fc33a2e8dba6ec9" + }, + "Std.Tactic.BVDecide.Normalize.Equal": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Equal.olean", + "sha256": "b811a7a95c0f5e441dfc6b4cefb0eec03e237442d2c57224fa4cf498436be742" + }, + "Std.Tactic.BVDecide.Normalize.Prop": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Prop.olean", + "sha256": "299264cac5f784ffcb12d7ec211033cf7913c4470e7ff363ade0cbbd2f18ea9a" + }, + "Std.Tactic.BVDecide.Reflect": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Reflect.olean", + "sha256": "6fa2f9828a59c1674437bee299f112a673ce7a30add77784b2bb610b6fdb50c6" + }, + "Std.Tactic.BVDecide.Syntax": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Syntax.olean", + "sha256": "0359dc3655c79f41a47af4d3c87485f738b79ac032d59738bbf48e16027416ba" + }, + "Std.Time": { + "relative_path": "lib/lean/Std/Time.olean", + "sha256": "0789687baa3558734be38cc4d152d748e9c6d2edf399507a1976246ce1db15d9" + }, + "Std.Time.Date": { + "relative_path": "lib/lean/Std/Time/Date.olean", + "sha256": "cb70aed3ccf7127c906dcab116c95c522aecb3987140814941c84eae42bf3f2a" + }, + "Std.Time.Date.Basic": { + "relative_path": "lib/lean/Std/Time/Date/Basic.olean", + "sha256": "f307e1a552373d28301792b5ca8bd0110b8e9d93eb81575689fbe3efd52b7ed8" + }, + "Std.Time.Date.PlainDate": { + "relative_path": "lib/lean/Std/Time/Date/PlainDate.olean", + "sha256": "9e9df12ccb5c285114cfdcf4039a2a021614747c9c45ccb6995722d248ddf3bb" + }, + "Std.Time.Date.Unit.Basic": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Basic.olean", + "sha256": "a073a7513d6b1fd55d88c56f341a3db71a933ee0563334e869db0e51618648f7" + }, + "Std.Time.Date.Unit.Day": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Day.olean", + "sha256": "5ebf7bb099376860bc2f18e7301dc33b2fba23a8de092dfa4ccc540a607edb1f" + }, + "Std.Time.Date.Unit.Month": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Month.olean", + "sha256": "795840aeee04727bd136c09d6f7c57c5eab32967bc5baa642caa071700d6f5ba" + }, + "Std.Time.Date.Unit.Week": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Week.olean", + "sha256": "1af7b14f7241b1157f7ede0be10b1ce8f84d59629fe9256ef2853f93f9920d10" + }, + "Std.Time.Date.Unit.Weekday": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Weekday.olean", + "sha256": "58a27e1054c0f7083540030928455a2f7f89568fd4df27904a992312e540431a" + }, + "Std.Time.Date.Unit.Year": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Year.olean", + "sha256": "1429b88657ba6078d953466050ae379a2c0ad32f908e64d3791b3f91271ab506" + }, + "Std.Time.Date.ValidDate": { + "relative_path": "lib/lean/Std/Time/Date/ValidDate.olean", + "sha256": "ace3749ecca5141ab1d66312455cbc165abe4a5e2a92e99181bdcab5a45dcaf8" + }, + "Std.Time.DateTime": { + "relative_path": "lib/lean/Std/Time/DateTime.olean", + "sha256": "bace36aa9c50b519ee6e46e6489fdfe349e77b3f7f00e952b8ddc54361639811" + }, + "Std.Time.DateTime.PlainDateTime": { + "relative_path": "lib/lean/Std/Time/DateTime/PlainDateTime.olean", + "sha256": "1296dc0c67ac54dbc5d0b1977fcfff082655daaea079ba088c070cdc4890924c" + }, + "Std.Time.DateTime.Timestamp": { + "relative_path": "lib/lean/Std/Time/DateTime/Timestamp.olean", + "sha256": "b4cd23a2f4ea4c96f2df2b83cfc655d0e19bef0238f6c044bf37b417faeb8756" + }, + "Std.Time.Duration": { + "relative_path": "lib/lean/Std/Time/Duration.olean", + "sha256": "768a81cc06f2a7b70728d660889a4e243f0fcfcf9270cdf735c7f95a26775a81" + }, + "Std.Time.Format": { + "relative_path": "lib/lean/Std/Time/Format.olean", + "sha256": "8d0928fbefb93f6de1f46e7e622f86beadb3e27115a29880eb0745b6fd74b7d4" + }, + "Std.Time.Format.Basic": { + "relative_path": "lib/lean/Std/Time/Format/Basic.olean", + "sha256": "23d409ed591814fd515cfb89781c282bf1990635241a8dac0fe4aa40668ce135" + }, + "Std.Time.Internal": { + "relative_path": "lib/lean/Std/Time/Internal.olean", + "sha256": "aecafe702fdd9d7c770b6b7d4d1843616ed03470014b13ea1ffc0d376c8091f0" + }, + "Std.Time.Internal.Bounded": { + "relative_path": "lib/lean/Std/Time/Internal/Bounded.olean", + "sha256": "49de757e44969f7b58b61b2218ba797db7d82682f64e272a249ffa13cec52d06" + }, + "Std.Time.Internal.UnitVal": { + "relative_path": "lib/lean/Std/Time/Internal/UnitVal.olean", + "sha256": "2293196364e88707f8cb1d82e99a18f155630a82a60f1ea6399f0144fdb6ef3f" + }, + "Std.Time.Notation": { + "relative_path": "lib/lean/Std/Time/Notation.olean", + "sha256": "9e9cd56d4bb18752d074d9a5545677bf880510f07038ad29595c0d88754b21c0" + }, + "Std.Time.Notation.Spec": { + "relative_path": "lib/lean/Std/Time/Notation/Spec.olean", + "sha256": "a08aada50626422dffd9168eccc354a0dda7769fc33d943c48d5c6dbeba380dd" + }, + "Std.Time.Time": { + "relative_path": "lib/lean/Std/Time/Time.olean", + "sha256": "aaa5e2da3807c23c60e80153e6a683af0835a58d89805dfb52cf9cfcdd09599b" + }, + "Std.Time.Time.Basic": { + "relative_path": "lib/lean/Std/Time/Time/Basic.olean", + "sha256": "08e7ff82d05c4f4aa49fc9b0702a1d499f31334df58a4dd693c92cf1860f50e8" + }, + "Std.Time.Time.HourMarker": { + "relative_path": "lib/lean/Std/Time/Time/HourMarker.olean", + "sha256": "be5bbcafbc86d200ae38d3681fa62eb89c5f92e54e658ce926f535a4ea5b7821" + }, + "Std.Time.Time.PlainTime": { + "relative_path": "lib/lean/Std/Time/Time/PlainTime.olean", + "sha256": "c341b0c38877ca56f7b8b758947b2e4cbe2cc5818286d78c4cb7d7f08fe60580" + }, + "Std.Time.Time.Unit.Basic": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Basic.olean", + "sha256": "d9802ce1313c896333ee3ad31889057c81f13bd40510da853d711018eb82deee" + }, + "Std.Time.Time.Unit.Hour": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Hour.olean", + "sha256": "cd26a34fd6964178efcfa29c86f9f240bb61dd601ec6e8a4daaa4fa1aeae1085" + }, + "Std.Time.Time.Unit.Millisecond": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Millisecond.olean", + "sha256": "f276ecae1131a214858236a4e6e3f495fc7e01d551d3b0bfa98c18301dea92f2" + }, + "Std.Time.Time.Unit.Minute": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Minute.olean", + "sha256": "7c9dc59498474221677908f899f8f8b98ccc4bcb9ced0a76b4b73608e03d1cb6" + }, + "Std.Time.Time.Unit.Nanosecond": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Nanosecond.olean", + "sha256": "6bc08672ed7d3e38d0343ce320ae09b2022fe6dab7e13c589dd11a12f6761147" + }, + "Std.Time.Time.Unit.Second": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Second.olean", + "sha256": "19a8c2259f0d51723c508d313c5d2da2896a5af464e9d6c809e047a772d49969" + }, + "Std.Time.Zoned": { + "relative_path": "lib/lean/Std/Time/Zoned.olean", + "sha256": "84ada81b95c5f170f68d7d2ec234bd3d007ad45d18364e531e5307f2c4d32617" + }, + "Std.Time.Zoned.Database": { + "relative_path": "lib/lean/Std/Time/Zoned/Database.olean", + "sha256": "5a324870d1bb5c102a79717c53840bb87ebbe4c7afb03499a31fb7aa51e04e8f" + }, + "Std.Time.Zoned.Database.Basic": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/Basic.olean", + "sha256": "76d13490a9d782e3c2616634c1d450f81d7978f836d5b7e6969361297a0287c9" + }, + "Std.Time.Zoned.Database.TZdb": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/TZdb.olean", + "sha256": "3345c6282c8805f291bfe6a6c219d4f8d21a2ab8aff2ad46e169aa33c073f777" + }, + "Std.Time.Zoned.Database.TzIf": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/TzIf.olean", + "sha256": "8fe12d507111f7ec04b7d1594959d190604da5bb3a0d944101472cedc2f4da02" + }, + "Std.Time.Zoned.Database.Windows": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/Windows.olean", + "sha256": "50d1a55ee0a71ddf05198a448f019c2bab95dab5d0e930157c220b8d349cbbdd" + }, + "Std.Time.Zoned.DateTime": { + "relative_path": "lib/lean/Std/Time/Zoned/DateTime.olean", + "sha256": "d313bdaf5fdefdc120eb57b5736d495d60ff33febf26db330e1fd99a7a2c396c" + }, + "Std.Time.Zoned.Offset": { + "relative_path": "lib/lean/Std/Time/Zoned/Offset.olean", + "sha256": "41d7f3f24b83359a4da791ff9d6e390bc19a09d0335086be6ac37b809ec75e5b" + }, + "Std.Time.Zoned.TimeZone": { + "relative_path": "lib/lean/Std/Time/Zoned/TimeZone.olean", + "sha256": "406fac44af49c5324d4857665a38f696fe47a0c15fbca5b458279e1c4a32c39e" + }, + "Std.Time.Zoned.ZoneRules": { + "relative_path": "lib/lean/Std/Time/Zoned/ZoneRules.olean", + "sha256": "86b9ebb4ce064c7f5c68fe3933a99d30e53d74c0a967669b7f23baffe77a4f1a" + }, + "Std.Time.Zoned.ZonedDateTime": { + "relative_path": "lib/lean/Std/Time/Zoned/ZonedDateTime.olean", + "sha256": "22285b4d4b6851745f3ba5b2fb79d739eb3000deebcc2ccdfbedec637ee53cd8" + } +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/missing-finite-stream.stderr b/formal/sonification/mat009/audit/verification-probe-002/missing-finite-stream.stderr new file mode 100644 index 0000000..1b5ee80 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/missing-finite-stream.stderr @@ -0,0 +1,7 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/verify_evidence.py", line 134, in + print(json.dumps(verify(args.evidence), sort_keys=True)) + ~~~~~~^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/verify_evidence.py", line 74, in verify + raise ValueError(f"receipt file inventory changed: {name}") +ValueError: receipt file inventory changed: mat009-finite-001 diff --git a/formal/sonification/mat009/audit/verification-probe-002/missing-finite-stream.stdout b/formal/sonification/mat009/audit/verification-probe-002/missing-finite-stream.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/missing-lean-stream.stderr b/formal/sonification/mat009/audit/verification-probe-002/missing-lean-stream.stderr new file mode 100644 index 0000000..e88fa72 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/missing-lean-stream.stderr @@ -0,0 +1,12 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify.py", line 176, in + print(json.dumps(verify(args.attempt, args.lean), sort_keys=True)) + ~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify.py", line 54, in verify + require({p.name for p in attempt.iterdir()} == set(files) | {manifest_path.name}, + ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + "retained evidence file inventory changed") + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify.py", line 40, in require + raise ValueError(message) +ValueError: retained evidence file inventory changed diff --git a/formal/sonification/mat009/audit/verification-probe-002/missing-lean-stream.stdout b/formal/sonification/mat009/audit/verification-probe-002/missing-lean-stream.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/missing-negative-mutant.stderr b/formal/sonification/mat009/audit/verification-probe-002/missing-negative-mutant.stderr new file mode 100644 index 0000000..d739924 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/missing-negative-mutant.stderr @@ -0,0 +1,12 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify_negative.py", line 112, in + print(json.dumps(verify(args.archive), sort_keys=True)) + ~~~~~~^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify_negative.py", line 49, in verify + require(observed == set(files) | {"ARCHIVE_MANIFEST.json"}, + ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + "negative archive file inventory changed") + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify_negative.py", line 32, in require + raise ValueError(message) +ValueError: negative archive file inventory changed diff --git a/formal/sonification/mat009/audit/verification-probe-002/missing-negative-mutant.stdout b/formal/sonification/mat009/audit/verification-probe-002/missing-negative-mutant.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/mutated-proof-checker.stderr b/formal/sonification/mat009/audit/verification-probe-002/mutated-proof-checker.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/mutated-proof-checker.stdout b/formal/sonification/mat009/audit/verification-probe-002/mutated-proof-checker.stdout new file mode 100644 index 0000000..7a46e13 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/mutated-proof-checker.stdout @@ -0,0 +1 @@ +{"error": "stale proof input: SplitModel.lean", "named_theorems": 0, "out": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-002/checker-result", "status": "FAIL"} diff --git a/formal/sonification/mat009/audit/verification-probe-002/mutated-source.stderr b/formal/sonification/mat009/audit/verification-probe-002/mutated-source.stderr new file mode 100644 index 0000000..5c2851d --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/mutated-source.stderr @@ -0,0 +1,15 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/source_drift_driver.py", line 32, in + sys.exit(main()) + ~~~~^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/source_drift_driver.py", line 27, in main + source_bind.verify() + ~~~~~~~~~~~~~~~~~~^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/source/source_bind.py", line 207, in verify + require((ROOT / path).read_bytes() == frozen_raw, + ~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + f"working-tree {label} differs from frozen release") + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/source/source_bind.py", line 36, in require + raise ValueError(message) +ValueError: working-tree target differs from frozen release diff --git a/formal/sonification/mat009/audit/verification-probe-002/mutated-source.stdout b/formal/sonification/mat009/audit/verification-probe-002/mutated-source.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/001/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/001/result.json new file mode 100644 index 0000000..c2d8d2e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/001/result.json @@ -0,0 +1,17 @@ +{ + "argv": [ + "python3", + "formal/sonification/mat009/lean/negative.py", + "--lean", + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--out", + "formal/sonification/mat009/lean/negative/001/reproduction" + ], + "cause": "non-unique campaign mutation anchor; no mutation cases executed", + "exit_code": 1, + "script_commit": "574c9ec", + "script_sha256": "5c2894a70267b2eff82241b0aa2cf6e36079ecac451edc401eee9736368ebe2b", + "status": "FAILED_DEVELOPMENT_ATTEMPT", + "stderr_sha256": "405a13f88a20584865d5e7aba8059024eb0af7580e0f788a8c55cb3cda3cf466", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/001/runner.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/001/runner.stderr new file mode 100644 index 0000000..5281259 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/001/runner.stderr @@ -0,0 +1,17 @@ +Traceback (most recent call last): + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 171, in + sys.exit(main()) + ~~~~^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 147, in main + for name, mutation in variants().items()] + ~~~~~~~~^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 48, in variants + replace_once(split, + ~~~~~~~~~~~~^^^^^^^ + "s.campaigns role key \u2228 (role = row.role ∧ key = row.campaign)", + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + "(role = row.role ∧ key = row.campaign)"), + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/negative.py", line 27, in replace_once + raise ValueError(f"mutation anchor is not unique: {before[:60]!r}") +ValueError: mutation anchor is not unique: 's.campaigns role key ∨ (role = row.role ∧ key = row.campaign' diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/001/runner.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/001/runner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..338f088 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout @@ -0,0 +1,17 @@ +DiagnosticFirstOwner.lean:23:13: warning: unused variable `first` +note: this linter can be disabled with `set_option linter.unusedVariables false` +DiagnosticFirstOwner.lean:35:68: error: unsolved goals +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:55:2: error: unsolved goals +case pos +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:75:38: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/mutant-source.lean.txt new file mode 100644 index 0000000..7dd6c18 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/mutant-source.lean.txt @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some candidate + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/result.json new file mode 100644 index 0000000..c006eca --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/change_diagnostic_first_owner_update/result.json @@ -0,0 +1,37 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-qzlh1__l/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-qzlh1__l/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "DiagnosticFirstOwner", + "mutant_sha256": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner", + "target_module": "DiagnosticFirstOwner" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout new file mode 100644 index 0000000..7afbe9e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout @@ -0,0 +1,29 @@ +SplitModel.lean:157:2: error: tactic 'rfl' failed, the left-hand side + (step s row).crossed +is not definitionally equal to the right-hand side + s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +s : State +row : Row +⊢ (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +SplitModel.lean:173:4: error: type mismatch + Or.inl h +has type + s.crossed ∨ ?m.4965 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:260:33: error: application type mismatch + ih (step s row) (Or.inl h) +argument + Or.inl h +has type + s.crossed ∨ ?m.5382 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:285:36: error: application type mismatch + scan_crossed_sticky (step (scan s before) row) after (Or.inr h) +argument + Or.inr h +has type + ?m.5421 ∨ ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role : Prop +but is expected to have type + (step (scan s before) row).crossed : Prop diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/mutant-source.lean.txt new file mode 100644 index 0000000..bf51182 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/result.json new file mode 100644 index 0000000..e668f74 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_cross_conflict_stickiness/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_cross_conflict_stickiness-b7mgdi0g/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "timed_out": false + } + ], + "detected": false, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "SplitModel", + "mutant_sha256": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stdout new file mode 100644 index 0000000..4bac996 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/build-00-SplitModel.stdout @@ -0,0 +1,42 @@ +SplitModel.lean:79:23: error: application type mismatch + And.intro (Or.inl htrain) +argument + Or.inl htrain +has type + s.campaigns Role.train key ∨ ?m.3876 : Prop +but is expected to have type + (step s row).campaigns Role.train key : Prop +SplitModel.lean:147:4: error: tactic 'rfl' failed, the left-hand side + (step s row).campaigns role key +is not definitionally equal to the right-hand side + s.campaigns role key ∨ role = row.role ∧ key = row.campaign +case refine_3 +s : State +row : Row +role : Role +key : String +⊢ (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign +SplitModel.lean:169:4: error: type mismatch + Or.inl h +has type + s.campaigns role campaign ∨ ?m.4953 : Prop +but is expected to have type + (step s row).campaigns role campaign : Prop +SplitModel.lean:222:21: error: unsolved goals +case cons +role : Role +key : String +row : Row +rest : List Row +ih : + ∀ (s : State), + (scan s rest).campaigns role key ↔ s.campaigns role key ∨ ∃ row, row ∈ rest ∧ row.role = role ∧ row.campaign = key +s : State +hhead : + (∃ r, r ∈ row :: rest ∧ r.role = role ∧ r.campaign = key) ↔ + row.role = role ∧ row.campaign = key ∨ ∃ r, r ∈ rest ∧ r.role = role ∧ r.campaign = key +⊢ (role = row.role ∧ key = row.campaign ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign) ↔ + role = row.role ∧ key = row.campaign ∨ + s.campaigns role key ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign +SplitModel.lean:368:35: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/mutant-source.lean.txt new file mode 100644 index 0000000..abf1e5e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/result.json new file mode 100644 index 0000000..ef8a788 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/drop_historical_campaign_membership/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_historical_campaign_membership-797k1qgn/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "SplitModel", + "mutant_sha256": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stdout new file mode 100644 index 0000000..1e4568e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/build-04-LeanAudit.stdout @@ -0,0 +1,1493 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: project axiom declaration MAT009.fabricated_physical_admission diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/mutant-source.lean.txt new file mode 100644 index 0000000..6fb45d8 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom fabricated_physical_admission : False + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/result.json new file mode 100644 index 0000000..72ae8e3 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_project_axiom/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-91lbflpl/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "project axiom declaration", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-00-SplitModel.stdout new file mode 100644 index 0000000..a165e03 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-00-SplitModel.stdout @@ -0,0 +1 @@ +SplitModel.lean:379:4: warning: declaration uses 'sorry' diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stdout new file mode 100644 index 0000000..8baf730 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/build-04-LeanAudit.stdout @@ -0,0 +1,1500 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: unapproved transitive axiom sorryAx in MAT009.hidden_unproved (origin SplitModel) diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/mutant-source.lean.txt new file mode 100644 index 0000000..287973b --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +def hidden_unproved : Nat := by sorry + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/result.json new file mode 100644 index 0000000..c24d4fb --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/prohibited_sorry/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-o9qvh653/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "timed_out": false + } + ], + "detected": false, + "expected_diagnostic_text": "sorry", + "expected_failure_module": "SplitModel", + "mutant_sha256": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/result.json new file mode 100644 index 0000000..6215fda --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/result.json @@ -0,0 +1,47 @@ +{ + "REFINEMENT_PROVED": "OPEN", + "cases": [ + { + "detected": false, + "expected_failure_module": "SplitModel", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "SplitModel", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "TypedConsumer", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer" + }, + { + "detected": true, + "expected_failure_module": "DiagnosticFirstOwner", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit" + }, + { + "detected": false, + "expected_failure_module": "SplitModel", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit" + } + ], + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "negative_runner_commit": "496c90c97ef0e5e0294dee706a842a888a3c47ea", + "negative_runner_sha256": "b06e5f54e157c61475661e5066321e65f3692b177e116f52c18f47337ce043c3", + "proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "scope": "negative controls for mathematical proof and trust checker only", + "status": "FAIL" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..85516a3 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout @@ -0,0 +1,68 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff : True +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +TypedConsumer.lean:43:9: error: function expected at + M009_R6_final_leakage_iff +term has type + True +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' does not depend on any axioms +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, sorryAx, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/mutant-source.lean.txt new file mode 100644 index 0000000..bd8b105 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/mutant-source.lean.txt @@ -0,0 +1,369 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff : True := by trivial + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/result.json new file mode 100644 index 0000000..9882436 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/002/weaken_final_leakage_theorem/result.json @@ -0,0 +1,50 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-tdtq_18o/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-tdtq_18o/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-tdtq_18o/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "M009_R6_final_leakage_iff", + "expected_failure_module": "TypedConsumer", + "mutant_sha256": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..338f088 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout @@ -0,0 +1,17 @@ +DiagnosticFirstOwner.lean:23:13: warning: unused variable `first` +note: this linter can be disabled with `set_option linter.unusedVariables false` +DiagnosticFirstOwner.lean:35:68: error: unsolved goals +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:55:2: error: unsolved goals +case pos +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:75:38: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/mutant-source.lean.txt new file mode 100644 index 0000000..7dd6c18 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/mutant-source.lean.txt @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some candidate + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/result.json new file mode 100644 index 0000000..fb1e6cb --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/change_diagnostic_first_owner_update/result.json @@ -0,0 +1,37 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-5g641ca4/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-5g641ca4/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "DiagnosticFirstOwner", + "mutant_sha256": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner", + "target_module": "DiagnosticFirstOwner" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout new file mode 100644 index 0000000..7afbe9e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout @@ -0,0 +1,29 @@ +SplitModel.lean:157:2: error: tactic 'rfl' failed, the left-hand side + (step s row).crossed +is not definitionally equal to the right-hand side + s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +s : State +row : Row +⊢ (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +SplitModel.lean:173:4: error: type mismatch + Or.inl h +has type + s.crossed ∨ ?m.4965 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:260:33: error: application type mismatch + ih (step s row) (Or.inl h) +argument + Or.inl h +has type + s.crossed ∨ ?m.5382 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:285:36: error: application type mismatch + scan_crossed_sticky (step (scan s before) row) after (Or.inr h) +argument + Or.inr h +has type + ?m.5421 ∨ ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role : Prop +but is expected to have type + (step (scan s before) row).crossed : Prop diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/mutant-source.lean.txt new file mode 100644 index 0000000..bf51182 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/result.json new file mode 100644 index 0000000..4cf3c03 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_cross_conflict_stickiness/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_cross_conflict_stickiness-mplmly4j/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "application type mismatch", + "expected_failure_module": "SplitModel", + "mutant_sha256": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stdout new file mode 100644 index 0000000..4bac996 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/build-00-SplitModel.stdout @@ -0,0 +1,42 @@ +SplitModel.lean:79:23: error: application type mismatch + And.intro (Or.inl htrain) +argument + Or.inl htrain +has type + s.campaigns Role.train key ∨ ?m.3876 : Prop +but is expected to have type + (step s row).campaigns Role.train key : Prop +SplitModel.lean:147:4: error: tactic 'rfl' failed, the left-hand side + (step s row).campaigns role key +is not definitionally equal to the right-hand side + s.campaigns role key ∨ role = row.role ∧ key = row.campaign +case refine_3 +s : State +row : Row +role : Role +key : String +⊢ (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign +SplitModel.lean:169:4: error: type mismatch + Or.inl h +has type + s.campaigns role campaign ∨ ?m.4953 : Prop +but is expected to have type + (step s row).campaigns role campaign : Prop +SplitModel.lean:222:21: error: unsolved goals +case cons +role : Role +key : String +row : Row +rest : List Row +ih : + ∀ (s : State), + (scan s rest).campaigns role key ↔ s.campaigns role key ∨ ∃ row, row ∈ rest ∧ row.role = role ∧ row.campaign = key +s : State +hhead : + (∃ r, r ∈ row :: rest ∧ r.role = role ∧ r.campaign = key) ↔ + row.role = role ∧ row.campaign = key ∨ ∃ r, r ∈ rest ∧ r.role = role ∧ r.campaign = key +⊢ (role = row.role ∧ key = row.campaign ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign) ↔ + role = row.role ∧ key = row.campaign ∨ + s.campaigns role key ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign +SplitModel.lean:368:35: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/mutant-source.lean.txt new file mode 100644 index 0000000..abf1e5e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/result.json new file mode 100644 index 0000000..60e4592 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/drop_historical_campaign_membership/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_historical_campaign_membership-4ipi38ta/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "SplitModel", + "mutant_sha256": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stdout new file mode 100644 index 0000000..1e4568e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/build-04-LeanAudit.stdout @@ -0,0 +1,1493 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: project axiom declaration MAT009.fabricated_physical_admission diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/mutant-source.lean.txt new file mode 100644 index 0000000..6fb45d8 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom fabricated_physical_admission : False + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/result.json new file mode 100644 index 0000000..a53a3d7 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_project_axiom/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-q9car2xt/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "project axiom declaration", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-00-SplitModel.stdout new file mode 100644 index 0000000..a165e03 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-00-SplitModel.stdout @@ -0,0 +1 @@ +SplitModel.lean:379:4: warning: declaration uses 'sorry' diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stdout new file mode 100644 index 0000000..8baf730 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/build-04-LeanAudit.stdout @@ -0,0 +1,1500 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: unapproved transitive axiom sorryAx in MAT009.hidden_unproved (origin SplitModel) diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/mutant-source.lean.txt b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/mutant-source.lean.txt new file mode 100644 index 0000000..287973b --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +def hidden_unproved : Nat := by sorry + +end MAT009 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/result.json new file mode 100644 index 0000000..4fcaa6e --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/prohibited_sorry/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-rq12gljs/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "sorryAx", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/result.json new file mode 100644 index 0000000..7831e91 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/result.json @@ -0,0 +1,47 @@ +{ + "REFINEMENT_PROVED": "OPEN", + "cases": [ + { + "detected": true, + "expected_failure_module": "SplitModel", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "SplitModel", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "TypedConsumer", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer" + }, + { + "detected": true, + "expected_failure_module": "DiagnosticFirstOwner", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit" + } + ], + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "negative_runner_commit": "5620029fb724ac41827a0c41c4c677b9594464f3", + "negative_runner_sha256": "874ca7ff059394e97cc908d921dec51bbc0ff852c354baf1c8da7a7d557a352c", + "proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "scope": "negative controls for mathematical proof and trust checker only", + "status": "PASS" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..85516a3 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout @@ -0,0 +1,68 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff : True +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +TypedConsumer.lean:43:9: error: function expected at + M009_R6_final_leakage_iff +term has type + True +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' does not depend on any axioms +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, sorryAx, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/result.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/result.json new file mode 100644 index 0000000..b9c7631 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/003/weaken_final_leakage_theorem/result.json @@ -0,0 +1,50 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-ndmeeadq/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-ndmeeadq/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-ndmeeadq/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "M009_R6_final_leakage_iff", + "expected_failure_module": "TypedConsumer", + "mutant_sha256": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/negative-archive/ARCHIVE_MANIFEST.json b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/ARCHIVE_MANIFEST.json new file mode 100644 index 0000000..6f64e7a --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/negative-archive/ARCHIVE_MANIFEST.json @@ -0,0 +1,109 @@ +{ + "accepted_attempt": "003", + "accepted_case_count": 6, + "files_sha256": { + "001/result.json": "092c87de243607f5721b9c55113b4223a2d3301e2c8c8acab82309c1afd24aeb", + "001/runner.stderr": "405a13f88a20584865d5e7aba8059024eb0af7580e0f788a8c55cb3cda3cf466", + "001/runner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "002/change_diagnostic_first_owner_update/mutant-source.lean.txt": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "002/change_diagnostic_first_owner_update/result.json": "759e5e2ec2b13fd4565d8419417628beb3a829357f53aa01ea18654ebef5c061", + "002/drop_cross_conflict_stickiness/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/drop_cross_conflict_stickiness/build-00-SplitModel.stdout": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "002/drop_cross_conflict_stickiness/mutant-source.lean.txt": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "002/drop_cross_conflict_stickiness/result.json": "ccce8d856ccf63fa7bef4808bed50b06c7b68617e91351da87e617a555f08dc7", + "002/drop_historical_campaign_membership/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/drop_historical_campaign_membership/build-00-SplitModel.stdout": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "002/drop_historical_campaign_membership/mutant-source.lean.txt": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "002/drop_historical_campaign_membership/result.json": "9cfe5f060dde968cf7677f36bf0fc7305ac4bc8085bb75f4fd751c0106d558dc", + "002/prohibited_project_axiom/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "002/prohibited_project_axiom/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_project_axiom/build-04-LeanAudit.stdout": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "002/prohibited_project_axiom/mutant-source.lean.txt": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "002/prohibited_project_axiom/result.json": "ae8389c3439aaf40f6df4dde82ca0c9bf2c5ac21077f0cbf7ebee9620c6ed20b", + "002/prohibited_sorry/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-00-SplitModel.stdout": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "002/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "002/prohibited_sorry/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/prohibited_sorry/build-04-LeanAudit.stdout": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "002/prohibited_sorry/mutant-source.lean.txt": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "002/prohibited_sorry/result.json": "863e887d061ebe06d802c76738510272c0d8b0521ca80a28728503f01db0e7cd", + "002/result.json": "7e72d51436d9d6c2408f1d92dda97d6f98d36707c5eb6b3b5ed9fbbce4143f6d", + "002/weaken_final_leakage_theorem/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "002/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "002/weaken_final_leakage_theorem/mutant-source.lean.txt": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "002/weaken_final_leakage_theorem/result.json": "8293ba459bb90648c0448890aae54d5d2b7c01cb09e8ee71d5a4e55e3cc5a1f6", + "003/change_diagnostic_first_owner_update/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/change_diagnostic_first_owner_update/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "003/change_diagnostic_first_owner_update/mutant-source.lean.txt": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "003/change_diagnostic_first_owner_update/result.json": "685fd47652221dab5c0e1f79a0d989cc6207881665c43c39ccbe685a2dd8eed4", + "003/drop_cross_conflict_stickiness/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/drop_cross_conflict_stickiness/build-00-SplitModel.stdout": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "003/drop_cross_conflict_stickiness/mutant-source.lean.txt": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "003/drop_cross_conflict_stickiness/result.json": "7b18e2919bfb7cd8fbf722edb1712539a6953cc86d811b8dc3f3d95f6f24e057", + "003/drop_historical_campaign_membership/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/drop_historical_campaign_membership/build-00-SplitModel.stdout": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "003/drop_historical_campaign_membership/mutant-source.lean.txt": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "003/drop_historical_campaign_membership/result.json": "d11211491d3439e7e9033ed21758a7b84404fd0ac18684f33a1fad8a9e3e101f", + "003/prohibited_project_axiom/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "003/prohibited_project_axiom/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_project_axiom/build-04-LeanAudit.stdout": "7b4aa6633245762b38060efdfb37ae7368d68023f8fc0f27d981d44e1de75df5", + "003/prohibited_project_axiom/mutant-source.lean.txt": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "003/prohibited_project_axiom/result.json": "3f1374a1123f4b4bdbe49e6bd6dd8f71ba2932050b464f5f71c7968ce2364d43", + "003/prohibited_sorry/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-00-SplitModel.stdout": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "003/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "003/prohibited_sorry/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/prohibited_sorry/build-04-LeanAudit.stdout": "f02439fb70cf48b85412492907f4ef496c6a882439f0e75f89787d1c6aba22d8", + "003/prohibited_sorry/mutant-source.lean.txt": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "003/prohibited_sorry/result.json": "0fc83b4837938c12c89bba62bb74070eda233d7ce44fa13a56a7073719e1197d", + "003/result.json": "6a2982ab558b83f472c60052c458055f30775d8e53d4f0a0015ff446d88d18dd", + "003/weaken_final_leakage_theorem/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "003/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "003/weaken_final_leakage_theorem/mutant-source.lean.txt": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "003/weaken_final_leakage_theorem/result.json": "65b7710a986a187cc2ed3d85878240fd22a59b4ce305b6ce3edc412b026768da" + }, + "nominal_proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "prior_failed_attempts": [ + "001", + "002" + ], + "schema": "sonification-mat009-lean-negative-archive-v1" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/result.json b/formal/sonification/mat009/audit/verification-probe-002/result.json new file mode 100644 index 0000000..6fe56c4 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/result.json @@ -0,0 +1,85 @@ +{ + "results": [ + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/source_drift_driver.py", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-002/source-drift" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "working-tree target differs", + "expected_rejection": true, + "label": "mutated-source", + "stderr_sha256": "021e7103eb994405fddeba20cd66b8ca666395754f4ee87291c8eade04adba96", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/verify_evidence.py", + "--evidence", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-002/source-receipts" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "receipt file inventory changed", + "expected_rejection": true, + "label": "missing-finite-stream", + "stderr_sha256": "fcce5190b7817e5decdc23ce4155c9f94d21c71c29e1888f23e942a4576855bc", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify.py", + "--attempt", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-002/lean-attempt" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "evidence file inventory changed", + "expected_rejection": true, + "label": "missing-lean-stream", + "stderr_sha256": "e8d665fbd4c7fc24de8d32efc6dd124738809c6c3e0d929ef9d5eb8d4cd46f44", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/verify_negative.py", + "--archive", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-002/negative-archive" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "archive file inventory changed", + "expected_rejection": true, + "label": "missing-negative-mutant", + "stderr_sha256": "a9e91f39be3d5749edd90f3cd159be517255a1b1d4374ea044f3f2e4d9f781ef", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/usr/bin/python3", + "-B", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/checker_mutant_driver.py", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/negative-probe-001/auxiliary_named_false_axiom/work", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/verification-probe-002/checker-result" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 1, + "expected_diagnostic": "stale proof input: SplitModel.lean", + "expected_rejection": true, + "label": "mutated-proof-checker", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "f91aba630e0c84a57297364e187a1f87c803c3f29734be08a8ce17e93ab62e6f" + } + ], + "source_mutant_sha256": "c9e950367bdd918511b3407b76866682af273e1072f72f476ae7398221cd5c3e", + "status": "PASS" +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-drift/materials/mat_spec_008.py b/formal/sonification/mat009/audit/verification-probe-002/source-drift/materials/mat_spec_008.py new file mode 100644 index 0000000..3117adb --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-drift/materials/mat_spec_008.py @@ -0,0 +1,625 @@ +"""MAT-SPEC-008: original-experiment evidence acquisition and independence gate. + +SPDX-License-Identifier: MPL-2.0 +Copyright (c) 2026 Trent Slade / QSOL-IMC. + +This is a source availability and measurement-provenance audit, not physical +replication, classifier evaluation, or generated sampled audio. +""" +from __future__ import annotations + +import csv +import io +import json +import os +import re +import stat +from contextlib import suppress +from fractions import Fraction +from itertools import combinations +from pathlib import Path, PurePosixPath + +from materials import mat_spec, mat_spec_006, mat_spec_007 + +PROFILE = "MAT-SPEC-008" +VERSION = "0.1.0" +PARENT_COMMIT = "b97348ff8fcf3f57764dec21a8914f153f96a745" +FOUNDATIONAL_DOI = "10.5281/zenodo.24062652" +SOURCE_PATH = "data/materials/helium4/mat_spec_008_source_catalogue.json" +SPEC_PATH = "spec/mat-spec-008.v0.1.json" +CATALOGUE_SHA256 = "6b6a973f46d1a748c5f94760a69e95899b5cc06ea717e1403b444eecdd880d88" +CAMPAIGNS = ("AL71_SVP", "GM75_SVP", "LC83_SVP", "STS52_1992") +FAMILIES = { + "AL71_SVP": "BELL_AHLERS", + "GM75_SVP": "MINNESOTA_GASPARINI_MOLDOVER", + "LC83_SVP": "STANFORD_LIPA", + "STS52_1992": "STANFORD_LIPA", +} +DOC_IDS = ( + "LC83_NASA_1984", "AHLERS_PRA_1971", "MUELLER_PRB_1976", + "GASPARINI_MOLDOVER_PRB_1975", "GASPARINI_GAETA_PRB_1978", + "STS52_NASA_1994", "STS52_PRL_1996", "STS52_PRB_2003", + "DONNELLY_BARENGHI_1998", "BARMATZ_RMP_2007", +) +OUTPUT_NAMES = frozenset({ + "contract.json", "source-catalogue.json", "campaigns.csv", + "candidate-pairs.csv", "measurement-audit.json", "admission.json", + "protocol.json", "manifest.json", +}) +IMPLEMENTATION_PATHS = ( + "materials/mat_spec_008.py", "scripts/build_mat_spec_008.py", +) +# Frozen MAT-SPEC-007 eight-output baseline from merged-main GitHub CI. +PARENT_V7_SHA256 = { + "audit.json": "0cc0d5ec77db4285ab379e15bbaf9a69b05cd367fd428cb6c227b8b8605a4d06", + "contract.json": "9e0eb1bf1e69599976dd57215ddeca956480c96ead61e36b055c67aa3125fc92", + "fit-summaries.csv": ( + "b3457eeafd8bda8f8b9ebd63d4cd72af825fd8bd04e2660d01f637578db79489" + ), + "lineage.json": "acdbabfe12116b930ca84ba8cc50a3e2a4f83493a6fbafef5915ffefae3727bd", + "manifest.json": "19fda1a900d051352d274f8b00fbd9e2ed7a44e1c90ae00c4e40bc30d1e6d5fc", + "pair-relations.csv": "3528b8f1700479d4f4ced51ab1a43535d800fea266d246a7a574967bf86ad2d4", + "receiver.json": "c2edb389a353e71748464fcfc4dbf88b92f1ce3bf28dad43d4980b0c5cdcde01", + "replication-gate.json": ( + "253b864e83ab4d5d36be16f6ec4ad71e0a7267a6b9c6fccfaf990a0b41950574" + ), +} + + +def _identity(value: object) -> str: + if ( + not isinstance(value, str) or not value or len(value) > 100 + or value != value.strip() or re.fullmatch(r"[A-Z0-9_]+", value) is None + ): + raise ValueError("invalid or empty source experiment identity") + return value + + +def parse_catalogue(raw: bytes) -> dict: + """Strict membership/lineage check; neither a PDF nor remote data fetch.""" + if mat_spec.sha256(raw) != CATALOGUE_SHA256: + raise ValueError("MAT-SPEC-008 source catalogue SHA-256 mismatch") + try: + data = json.loads(raw) + except (ValueError, UnicodeDecodeError) as exc: + raise ValueError("invalid source-catalogue JSON") from exc + if ( + data != EXPECTED_CATALOGUE + or data.get("profile") != PROFILE + or data.get("version") != VERSION + or len(data.get("source_docs", [])) != len(DOC_IDS) + ): + raise ValueError("MAT-SPEC-008 frozen source catalogue mismatch") + docs = data["source_docs"] + if tuple(d["doc_id"] for d in docs) != DOC_IDS: + raise ValueError("source catalogue identity drift") + if len({d["doc_id"] for d in docs}) != len(DOC_IDS): + raise ValueError("duplicate source document ID") + for d in docs: + _identity(d["doc_id"]) + campaign = d["campaign"] + if campaign is None: + if d["document_kind"] not in {"EVALUATED_COMPILATION", "SECONDARY_FIT_REVIEW"}: + raise ValueError("unassigned experiment identity") + elif _identity(campaign) not in CAMPAIGNS: + raise ValueError("unrecognized experiment campaign") + if campaign and d["lab_family"] != FAMILIES[campaign]: + raise ValueError("source-family mismatch") + if not isinstance(d["source_bound_measurement_rows"], int): + raise ValueError("invalid claimed original numeric row count") + if ( + d["source_bound_measurement_rows"] < 0 + or d["per_row_calibrated_uncertainty"] is not False + or d["orthogonal_phase_diagnostic"] is not False + ): + raise ValueError("forged admitted evidence flags") + return data + + +def source_audit( + catalogue: dict, actual_measurement_rows: list[dict], fit_summaries: list[dict] +) -> tuple[list[dict], list[dict], dict]: + """Do not promote a literature DOI or reanalysis to a measured campaign.""" + docs = catalogue["source_docs"] + if ( + len(actual_measurement_rows) != 12 + or len(fit_summaries) != 4 + or {r["source_campaign_id"] for r in actual_measurement_rows} + != {mat_spec_006.CAMPAIGN} + or tuple(r["acquisition_campaign"] for r in fit_summaries) != CAMPAIGNS + ): + raise ValueError("MAT-SPEC-006/007 original acquisition lineage drift") + if any( + r["row_uncertainty_J_per_mol_K"] is not None + or r["independent_physical_phase_diagnostic"] is not None + or r["independent_phase_label"] is not None + for r in actual_measurement_rows + ): + raise ValueError("forged original row uncertainties or phase diagnostics") + + totals = {camp: 0 for camp in CAMPAIGNS} + for d in docs: + if d["source_bound_measurement_rows"]: + if d["doc_id"] != "LC83_NASA_1984": + raise ValueError("unsupported independent numeric measurements") + totals["LC83_SVP"] += d["source_bound_measurement_rows"] + if totals["LC83_SVP"] != len(actual_measurement_rows): + raise ValueError("admitted NASA measurement count drift") + campaigns = [] + for camp in CAMPAIGNS: + records = [d for d in docs if d["campaign"] == camp] + original = [d for d in records if d["document_kind"] in { + "ORIGINAL_PROCESSED_MEASUREMENT_TABLE", + "ORIGINAL_EXPERIMENT_PUBLICATION", + "ORIGINAL_EXPERIMENT_CONFERENCE", + }] + if not original: + raise ValueError("campaign has no attributed original experimental source") + campaigns.append({ + "campaign": camp, + "lab_family": FAMILIES[camp], + "source_documents": len(records), + "original_source_docs": len(original), + "source_pinned_processed_measurement_rows": totals[camp], + "per_row_calibrated_uncertainties": 0, + "independent_phase_diagnostic_rows": 0, + "acquisition_run_independence_attested": False, + "admission_status": "BLOCKED_NO_INDEPENDENT_MEASUREMENT_PACKET", + }) + pairs = [] + for a, b in combinations(campaigns, 2): + pairs.append({ + "campaign_a": a["campaign"], "campaign_b": b["campaign"], + "distinct_published_campaigns": True, + "different_lab_family": a["lab_family"] != b["lab_family"], + "both_have_source_pinned_original_measurements": ( + a["source_pinned_processed_measurement_rows"] > 0 + and b["source_pinned_processed_measurement_rows"] > 0 + ), + "experiment_run_independence_attested": False, + "eligible_for_independent_replication": False, + }) + if ( + len(pairs) != 6 or sum(x["different_lab_family"] for x in pairs) != 5 + or sum(x["both_have_source_pinned_original_measurements"] for x in pairs) != 0 + ): + raise ValueError("independence pair conservation failure") + report = { + "profile": PROFILE, "version": VERSION, + "reviewed_publication_documents": len(docs), + "published_original_acquisition_campaigns": len(campaigns), + "distinct_lab_families": len(set(FAMILIES.values())), + "original_source_pinned_processed_measurement_campaigns": sum( + x["source_pinned_processed_measurement_rows"] > 0 for x in campaigns + ), + "source_pinned_processed_measurement_rows": len(actual_measurement_rows), + "available_row_level_calibrated_uncertainties": 0, + "available_independent_phase_diagnostic_rows": 0, + "secondary_review_fitted_records": len(fit_summaries), + "candidate_campaign_pairs": len(pairs), + "candidate_cross_lab_pairs": 5, + "measurement_level_replicable_pairs": 0, + "do_not_add_reanalyses_as_new_experiments": True, + "different_publications_not_independent_measurement_packets": True, + } + return campaigns, pairs, report + + +def _rows_csv(rows: list[dict]) -> bytes: + out = io.StringIO(newline="") + fields = tuple(rows[0]) + writer = csv.DictWriter(out, fieldnames=fields, lineterminator="\n") + writer.writeheader() + writer.writerows(rows) + return out.getvalue().encode("ascii") + + +def _decimal(value: object) -> Fraction: + if not isinstance(value, str) or re.fullmatch( + r"(?:0|[1-9][0-9]*)(?:\.[0-9]+)?", value + ) is None: + raise ValueError("missing or invalid positive calibrated quantity") + number = Fraction(value) + if number <= 0: + raise ValueError("missing or zero calibrated quantity") + return number + + +def validate_future_measurement_packet(records: list[dict]) -> dict: + """Structure only; caller assertions cannot prove real-world measurements.""" + reasons: set[str] = set() + if not records: + return { + "status": "BLOCKED", "reasons": ["EMPTY_MEASUREMENT_PACKET"], + "physical_evidence_admitted": False, "independence_authenticated": False, + } + experiment_to_lab: dict[str, str] = {} + experiment_to_source: dict[str, str] = {} + experiment_to_hash: dict[str, str] = {} + run_to_campaign: dict[str, str] = {} + document_to_campaign: dict[str, str] = {} + hash_to_campaign: dict[str, str] = {} + phases_by_campaign: dict[str, set[str]] = {} + seen_rows = set() + campaigns = set() + labs = set() + for row in records: + if not isinstance(row, dict): + reasons.add("MALFORMED_CANDIDATE_RECORD") + continue + try: + camp = _identity(row.get("campaign_id")) + lab = _identity(row.get("lab_family_id")) + run = _identity(row.get("original_run_id")) + doc = _identity(row.get("source_document_id")) + identifier = _identity(row.get("row_id")) + except ValueError: + reasons.add("MISSING_OR_INVALID_SOURCE_IDENTITIES") + continue + if identifier in seen_rows: + reasons.add("DUPLICATE_MEASUREMENT_ROW_ID") + seen_rows.add(identifier) + campaigns.add(camp) + labs.add(lab) + if camp in experiment_to_lab and experiment_to_lab[camp] != lab: + reasons.add("CAMPAIGN_LAB_IDENTITY_CONTRADICTION") + experiment_to_lab[camp] = lab + # Source, document and run identities must not migrate between + # purportedly independent acquisition campaigns. + source_key = doc + ":" + run + if camp in experiment_to_source and experiment_to_source[camp] != source_key: + reasons.add("CAMPAIGN_RUN_OR_DOCUMENT_INCONSISTENT") + experiment_to_source[camp] = source_key + for key, owner, prior in ( + ("REUSED_ORIGINAL_RUN_ACROSS_CAMPAIGNS", run_to_campaign, run), + ("REUSED_ORIGINAL_DOCUMENT_ACROSS_CAMPAIGNS", document_to_campaign, doc), + ): + if prior in owner and owner[prior] != camp: + reasons.add(key) + owner[prior] = camp + declared_phase = row.get("phase") + if not isinstance(declared_phase, str): + reasons.add("UNVERIFIED_PHASE_LABEL") + declared_phase = "INVALID" + phases_by_campaign.setdefault(camp, set()).add(declared_phase) + if row.get("source_type") != "ORIGINAL_EXPERIMENTAL_RECORD": + reasons.add("DERIVED_FIT_OR_COMPILATION_IS_NOT_PRIMARY_DATA") + if row.get("synthetic_fixture") is True: + reasons.add("SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT") + if row.get("diagnostic_basis") != "INDEPENDENT_NON_TEMPERATURE_DIAGNOSTIC": + reasons.add("CIRCULAR_OR_MISSING_PHASE_DIAGNOSTIC") + if declared_phase not in ("HE_I", "HE_II"): + reasons.add("UNVERIFIED_PHASE_LABEL") + try: + _decimal(row.get("measurement_value")) + _decimal(row.get("measurement_sigma")) + _decimal(row.get("diagnostic_sigma")) + except ValueError: + reasons.add("MISSING_CALIBRATED_MEASUREMENT_UNCERTAINTY") + digest = row.get("source_sha256") + if ( + not isinstance(digest, str) + or re.fullmatch(r"[0-9a-f]{64}", digest) is None + or row.get("pressure_condition") not in ( + "HE4_SVP", "DOCUMENTED_FIXED_PRESSURE" + ) + ): + reasons.add("SOURCE_HASH_OR_PHYSICAL_CONDITION_NOT_DOCUMENTED") + else: + if digest in hash_to_campaign and hash_to_campaign[digest] != camp: + reasons.add("REUSED_SOURCE_BYTES_ACROSS_CAMPAIGNS") + hash_to_campaign[digest] = camp + if camp in experiment_to_hash and experiment_to_hash[camp] != digest: + reasons.add("CAMPAIGN_SOURCE_BYTES_INCONSISTENT") + experiment_to_hash[camp] = digest + if any(phases != {"HE_I", "HE_II"} for phases in phases_by_campaign.values()): + reasons.add("BOTH_PHASES_REQUIRED_FOR_EACH_CAMPAIGN") + if len(campaigns) < 2 or len(labs) < 2: + reasons.add("TWO_INDEPENDENT_CAMPAIGNS_AND_LABS_REQUIRED") + if len(set(experiment_to_source.values())) < 2: + reasons.add("DISTINCT_ORIGINAL_RUNS_REQUIRED") + # Do not use the user's declared campaign strings as proof of independence. + return { + "status": "BLOCKED" if reasons else "STRUCTURAL_ONLY_UNAUTHENTICATED", + "reasons": sorted(reasons), + "candidate_rows": len(records), + "described_campaigns": len(campaigns), + "described_labs": len(labs), + "physical_evidence_admitted": False, + "independence_authenticated": False, + "heldout_accuracy": None, + "note": "A structural pass never authenticates original run bytes or phase labels", + } + + +def evidence_admission(report: dict, catalogue: dict) -> dict: + if ( + report["original_source_pinned_processed_measurement_campaigns"] != 1 + or report["source_pinned_processed_measurement_rows"] != 12 + or report["measurement_level_replicable_pairs"] != 0 + or report["available_row_level_calibrated_uncertainties"] != 0 + or report["available_independent_phase_diagnostic_rows"] != 0 + ): + raise ValueError("unanticipated scientific admission state") + return { + "status": "BLOCKED_INSUFFICIENT_INDEPENDENT_MEASUREMENT_DATA", + "source_catalogue_profile": catalogue["profile"], + "one_campaign_processed_excerpt": "REPLAY_VERIFIED", + "independent_experimental_replication": "NOT_DEMONSTRATED", + "distinct_campaigns_described": 4, + "independent_measurement_campaigns_with_source_pinned_rows": 1, + "independent_measurement_campaign_pair_count": 0, + "independently_verified_raw_acquisition_campaigns": 0, + "train_test_split": "NOT_PERFORMED", + "trained_phase_classifier": False, + "physical_phase_accuracy": None, + "source_separated_heldout_accuracy": None, + "calibrated_error_comparison": "BLOCKED_NO_PER_ROW_ERRORS", + "reasons": [ + "SECOND_INDEPENDENT_MEASUREMENT_LEVEL_CORPUS_NOT_ADMITTED", + "PUBLISHED_ARTICLE_OR_REFIT_NOT_AN_ORIGINAL_ROW_PACKET", + "NO_TWO_SOURCE_PINNED_CAMPAIGNS", + "ORIGINAL_PROCESSED_MEASUREMENT_ROWS_LACK_PER_ROW_ERRORS", + "NO_ORTHOGONAL_PHYSICAL_PHASE_LABELS", + "NO_INDEPENDENT_ORIGINAL_RUN_IDENTITY_AUTHENTICATION", + "NO_PREREGISTERED_SOURCE_SEPARATED_HELDOUT_EVALUATION", + ], + "next": "MAT-SPEC-009 may only attempt physical validation after independent admission", + "program_end": "MAT-SPEC-010", + "no_audio_generated": True, + } + + +def build_evidence(root: Path) -> dict[str, bytes]: + """Rebuild 001..007, verify source excerpt and export negative evidence.""" + parent = mat_spec_007.build_evidence(root) + if set(parent) != mat_spec_007.OUTPUT_NAMES: + raise ValueError("MAT-SPEC-007 parent artifact membership drift") + hashes = {name: mat_spec.sha256(raw) for name, raw in parent.items()} + if hashes != PARENT_V7_SHA256: + raise ValueError("frozen MAT-SPEC-007 parent output SHA-256 drift") + manifest = json.loads(parent["manifest.json"]) + if ( + manifest.get("profile") != "MAT-SPEC-007" + or manifest.get("version") != "0.1.0" + or manifest.get("parent_commit") != mat_spec_007.PARENT_COMMIT + or manifest.get("foundational_mat_spec_001_doi") != FOUNDATIONAL_DOI + ): + raise ValueError("unexpected MAT-SPEC-007 parent lineage") + for name, entry in manifest["outputs"].items(): + if name not in parent or mat_spec.sha256(parent[name]) != entry["sha256"]: + raise ValueError("MAT-SPEC-007 parent manifest inconsistency") + raw_catalogue = mat_spec.read_regular(root / SOURCE_PATH) + raw_spec = mat_spec.read_regular(root / SPEC_PATH) + catalogue = parse_catalogue(raw_catalogue) + try: + contract = json.loads(raw_spec) + except (UnicodeDecodeError, ValueError) as exc: + raise ValueError("invalid MAT-SPEC-008 contract") from exc + if contract != EXPECTED_SPEC: + raise ValueError("frozen MAT-SPEC-008 contract drift") + original_bytes = mat_spec.read_regular(root / mat_spec_006.DATA_PATH) + original = mat_spec_006.parse_measurements(original_bytes) + fits = list(csv.DictReader(io.StringIO(parent["fit-summaries.csv"].decode("ascii")))) + campaigns, pairs, report = source_audit(catalogue, original, fits) + admission = evidence_admission(report, catalogue) + protocol = { + "status": "FUTURE_MEASUREMENT_PACKET_PREFLIGHT", + "review_timing": "DESIGNED_AFTER_INSPECTING_EXISTING_SOURCES", + "required": [ + "TWO_PROVEN_INDEPENDENT_ORIGINAL_MEASUREMENT_CAMPAIGNS", + "ROW_LEVEL_MEASUREMENT_AND_DIAGNOSTIC_ERRORS", + "NON_TEMPERATURE_DERIVED_PHASE_LABELS", + "NO_SOURCE_RUN_OR_CROSS_LAB_DEPENDENCY", + "SOURCE_PINNED_MEASUREMENT_PACKET_AND_CALIBRATION", + "PREREGISTERED_SOURCE_SEPARATED_HELDOUT_PLAN", + ], + "synthetic_fixture_controls_are_empirical_evidence": False, + "structural_pass_alone_can_admit_physics": False, + "performance_score": None, + "program_end": "MAT-SPEC-010", + } + products = { + "contract.json": mat_spec.canonical_json(contract), + "source-catalogue.json": mat_spec.canonical_json(catalogue), + "campaigns.csv": _rows_csv(campaigns), + "candidate-pairs.csv": _rows_csv(pairs), + "measurement-audit.json": mat_spec.canonical_json(report), + "admission.json": mat_spec.canonical_json(admission), + "protocol.json": mat_spec.canonical_json(protocol), + } + implementation = { + path: mat_spec.sha256(mat_spec.read_regular(root / path)) + for path in IMPLEMENTATION_PATHS + } + output_manifest = { + "profile": PROFILE, "version": VERSION, "parent_commit": PARENT_COMMIT, + "parent_outputs": { + name: {"sha256": value, "bytes": len(parent[name])} + for name, value in sorted(hashes.items()) + }, + "source_catalogue": { + "path": SOURCE_PATH, "sha256": mat_spec.sha256(raw_catalogue), + "bytes": len(raw_catalogue), + }, + "original_measurement_excerpt": { + "path": mat_spec_006.DATA_PATH, + "sha256": mat_spec.sha256(original_bytes), + "rows": len(original), + }, + "contract": {"path": SPEC_PATH, "sha256": mat_spec.sha256(raw_spec)}, + "implementation": implementation, + "outputs": { + name: {"sha256": mat_spec.sha256(raw), "bytes": len(raw)} + for name, raw in sorted(products.items()) + }, + "foundational_mat_spec_001_doi": FOUNDATIONAL_DOI, + "serialization": "ASCII canonical sorted compact JSON LF, CSV LF", + "manifest_self_hash": None, + "canonical_pcm_sha256": None, + "canonical_wav_sha256": None, + "audio_generated": False, + } + products["manifest.json"] = mat_spec.canonical_json(output_manifest) + return products + + +def write_evidence(root: Path, destination: str, products: dict[str, bytes]) -> Path: + """Anchored no-follow exclusive symbolic-only output.""" + path = PurePosixPath(destination) + if ( + not destination or path.is_absolute() or "\\" in destination + or any(component in {"", ".", ".."} for component in destination.split("/")) + ): + raise ValueError("invalid symbolic output destination") + if set(products) != OUTPUT_NAMES or any( + PurePosixPath(name).name != name + or Path(name).suffix not in {".csv", ".json"} for name in products + ): + raise ValueError("forbidden non-symbolic output membership") + flags = os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW + fds = [os.open(root, flags)] + try: + for component in path.parts[:-1]: + with suppress(FileExistsError): + os.mkdir(component, mode=0o755, dir_fd=fds[-1]) + fds.append(os.open(component, flags, dir_fd=fds[-1])) + parent_fd = fds[-1] + os.mkdir(path.parts[-1], mode=0o755, dir_fd=parent_fd) + fds.append(os.open(path.parts[-1], flags, dir_fd=parent_fd)) + output_fd = fds[-1] + for name in sorted(products): + fd = os.open( + name, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, + mode=0o644, dir_fd=output_fd, + ) + with os.fdopen(fd, "wb") as target: + target.write(products[name]) + opened = os.fstat(output_fd) + visible = os.stat(path.parts[-1], dir_fd=parent_fd, follow_symlinks=False) + if not stat.S_ISDIR(visible.st_mode) or ( + opened.st_dev, opened.st_ino + ) != (visible.st_dev, visible.st_ino): + raise ValueError("output directory changed during export") + finally: + for fd in reversed(fds): + os.close(fd) + return root / path + +EXPECTED_CATALOGUE = json.loads( + "{\"profile\":\"MAT-SPEC-008\",\"version\":\"0.1.0\",\"scope\":\"Source-" + "pinned original helium-4 SVP temperature-series measurement " + "packets from at least two independent acquisitions; an artic" + "le citation, figure or fitted exponent is not an original me" + "asurement packet\",\"review_date\":\"2026-11-09\",\"numeric_source" + "\":\"MAT-SPEC-006 frozen 12-row Lipa-Chui 1984 Appendix A proc" + "essed calorimetry extract\",\"parent_fit_source\":\"MAT-SPEC-007" + " frozen four-row 2007 secondary review fit-summary table\",\"s" + "ource_docs\":[{\"doc_id\":\"LC83_NASA_1984\",\"document_kind\":\"ORI" + "GINAL_PROCESSED_MEASUREMENT_TABLE\",\"campaign\":\"LC83_SVP\",\"la" + "b_family\":\"STANFORD_LIPA\",\"primary_doi\":\"10.1103/PhysRevLett" + ".51.2291\",\"url\":\"https://ntrs.nasa.gov/citations/19860021083" + "\",\"source_bound_measurement_rows\":12,\"per_row_calibrated_unc" + "ertainty\":false,\"orthogonal_phase_diagnostic\":false,\"conditi" + "on\":\"HE4_SVP\",\"scope_note\":\"1984 NASA-CR-177037 original Lip" + "a-Chui gravity-corrected averaged table, not raw instrument " + "stream\"},{\"doc_id\":\"AHLERS_PRA_1971\",\"document_kind\":\"ORIGIN" + "AL_EXPERIMENT_PUBLICATION\",\"campaign\":\"AL71_SVP\",\"lab_family" + "\":\"BELL_AHLERS\",\"primary_doi\":\"10.1103/PhysRevA.3.696\",\"url\"" + ":\"https://doi.org/10.1103/PhysRevA.3.696\",\"source_bound_meas" + "urement_rows\":0,\"per_row_calibrated_uncertainty\":false,\"orth" + "ogonal_phase_diagnostic\":false,\"condition\":\"HE4_SVP\",\"scope_" + "note\":\"Original SVP calorimetry published; no per-row origin" + "al numeric data acquired and hash-pinned by this profile\"},{" + "\"doc_id\":\"MUELLER_PRB_1976\",\"document_kind\":\"MIXED_NEW_PRESS" + "URE_EXPERIMENT_AND_SVP_REANALYSIS\",\"campaign\":\"AL71_SVP\",\"la" + "b_family\":\"BELL_AHLERS\",\"primary_doi\":\"10.1103/PhysRevB.14.2" + "096\",\"url\":\"https://doi.org/10.1103/PhysRevB.14.2096\",\"sourc" + "e_bound_measurement_rows\":0,\"per_row_calibrated_uncertainty\"" + ":false,\"orthogonal_phase_diagnostic\":false,\"condition\":\"SVP_" + "FIT_FROM_AHLERS_PRIOR_DATA;NEW_PRESSURE_EXPANSION_OUTSIDE_SC" + "OPE\",\"scope_note\":\"Reports independent pressurized thermal-e" + "xpansion data too; SVP heat-capacity fit in MAT-SPEC-007 tra" + "ces earlier Ahlers measurement; not a new SVP calorimetry da" + "taset\"},{\"doc_id\":\"GASPARINI_MOLDOVER_PRB_1975\",\"document_ki" + "nd\":\"ORIGINAL_EXPERIMENT_PUBLICATION\",\"campaign\":\"GM75_SVP\"," + "\"lab_family\":\"MINNESOTA_GASPARINI_MOLDOVER\",\"primary_doi\":\"1" + "0.1103/PhysRevB.12.93\",\"url\":\"https://doi.org/10.1103/PhysRe" + "vB.12.93\",\"source_bound_measurement_rows\":0,\"per_row_calibra" + "ted_uncertainty\":false,\"orthogonal_phase_diagnostic\":false,\"" + "condition\":\"PURE_HE4_SVP_SUBSET_NOT_ACQUIRED\",\"scope_note\":\"" + "Original study includes pure helium-4 and 3He-4He mixtures; " + "no pure-4He source-bound original numeric rows admitted\"},{\"" + "doc_id\":\"GASPARINI_GAETA_PRB_1978\",\"document_kind\":\"REANALYS" + "IS\",\"campaign\":\"GM75_SVP\",\"lab_family\":\"MINNESOTA_GASPARINI_" + "MOLDOVER\",\"primary_doi\":\"10.1103/PhysRevB.17.1466\",\"url\":\"ht" + "tps://doi.org/10.1103/PhysRevB.17.1466\",\"source_bound_measur" + "ement_rows\":0,\"per_row_calibrated_uncertainty\":false,\"orthog" + "onal_phase_diagnostic\":false,\"condition\":\"HE4_SVP_FIT_REANAL" + "YSIS\",\"scope_note\":\"Fit reanalysis of earlier source measure" + "ments, not a new original SVP calorimeter acquisition\"},{\"do" + "c_id\":\"STS52_NASA_1994\",\"document_kind\":\"ORIGINAL_EXPERIMENT" + "_CONFERENCE\",\"campaign\":\"STS52_1992\",\"lab_family\":\"STANFORD_" + "LIPA\",\"primary_doi\":null,\"url\":\"https://ntrs.nasa.gov/citati" + "ons/19950007794\",\"source_bound_measurement_rows\":0,\"per_row_" + "calibrated_uncertainty\":false,\"orthogonal_phase_diagnostic\":" + "false,\"condition\":\"HE4_LAMBDA_MICROGRAVITY;RUN_LEVEL_CONDITI" + "ONS_NOT_PINNED\",\"scope_note\":\"1992 orbital experiment confer" + "ence summary; no primary per-row original data pinned\"},{\"do" + "c_id\":\"STS52_PRL_1996\",\"document_kind\":\"ORIGINAL_EXPERIMENT_" + "PUBLICATION\",\"campaign\":\"STS52_1992\",\"lab_family\":\"STANFORD_" + "LIPA\",\"primary_doi\":\"10.1103/PhysRevLett.76.944\",\"url\":\"http" + "s://doi.org/10.1103/PhysRevLett.76.944\",\"source_bound_measur" + "ement_rows\":0,\"per_row_calibrated_uncertainty\":false,\"orthog" + "onal_phase_diagnostic\":false,\"condition\":\"HE4_LAMBDA_MICROGR" + "AVITY\",\"scope_note\":\"1996 report of the 1992 orbital experim" + "ent, not a second orbital acquisition\"},{\"doc_id\":\"STS52_PRB" + "_2003\",\"document_kind\":\"REVISED_ANALYSIS_SAME_CAMPAIGN\",\"cam" + "paign\":\"STS52_1992\",\"lab_family\":\"STANFORD_LIPA\",\"primary_do" + "i\":\"10.1103/PhysRevB.68.174518\",\"url\":\"https://doi.org/10.11" + "03/PhysRevB.68.174518\",\"source_bound_measurement_rows\":0,\"pe" + "r_row_calibrated_uncertainty\":false,\"orthogonal_phase_diagno" + "stic\":false,\"condition\":\"HE4_SVP_MICROGRAVITY\",\"scope_note\":" + "\"2003 revised analysis of the STS-52 1992 experiment, not a " + "new acquisition; revised article describes raw experimental " + "error handling but source rows not pinned\"},{\"doc_id\":\"DONNE" + "LLY_BARENGHI_1998\",\"document_kind\":\"EVALUATED_COMPILATION\",\"" + "campaign\":null,\"lab_family\":null,\"primary_doi\":\"10.1063/1.55" + "6028\",\"url\":\"https://doi.org/10.1063/1.556028\",\"source_bound" + "_measurement_rows\":0,\"per_row_calibrated_uncertainty\":false," + "\"orthogonal_phase_diagnostic\":false,\"condition\":\"HE4_SVP_REC" + "OMMENDED_DATA_NOT_RAW\",\"scope_note\":\"MAT-SPEC-005 evaluated " + "recommended tables compile older experiments, not an indepen" + "dently sourced experimental campaign\"},{\"doc_id\":\"BARMATZ_RM" + "P_2007\",\"document_kind\":\"SECONDARY_FIT_REVIEW\",\"campaign\":nu" + "ll,\"lab_family\":null,\"primary_doi\":\"10.1103/RevModPhys.79.1\"" + ",\"url\":\"https://doi.org/10.1103/RevModPhys.79.1\",\"source_bou" + "nd_measurement_rows\":0,\"per_row_calibrated_uncertainty\":fals" + "e,\"orthogonal_phase_diagnostic\":false,\"condition\":\"HE4_SVP_F" + "IT_SUMMARIES_NOT_ROW_DATA\",\"scope_note\":\"MAT-SPEC-007 four f" + "itted parameter records are secondary review values from dis" + "tinct experiments, not raw row-level measurements\"}],\"noncla" + "im\":\"A different article or author is not measurement-level " + "independent reproduction; no per-row errors or independently" + " measured phase labels are admitted.\"}" +) +EXPECTED_SPEC = json.loads( + "{\"profile\":\"MAT-SPEC-008\",\"version\":\"0.1.0\",\"parent_profile\"" + ":\"MAT-SPEC-007 v0.1.0\",\"parent_merge_commit\":\"b97348ff8fcf3f" + "57764dec21a8914f153f96a745\",\"foundational_mat_spec_001_doi\":" + "\"10.5281/zenodo.24062652\",\"source_catalogue\":\"data/materials" + "/helium4/mat_spec_008_source_catalogue.json\",\"source_of_nume" + "rical_rows\":\"MAT-SPEC-006 SHA-pinned original processed Lipa" + "-Chui table\",\"review_fit_source\":\"MAT-SPEC-007 SHA-pinned se" + "condary fit table\",\"min_independent_measurement_campaigns\":2" + ",\"require_source_bound_rows\":true,\"require_measurement_level" + "_uncertainty\":true,\"require_orthogonal_diagnostic\":true,\"req" + "uire_lineage_verified_no_shared_run\":true,\"candidate_output\"" + ":\"STRUCTURAL_ONLY_UNAUTHENTICATED at best; never label it em" + "pirical admission\",\"physical_results\":\"NO_PHASE_CLASSIFIER_N" + "O_HOLDOUT_ACCURACY_NO_RAW_INDEPENDENT_REPLICATION\",\"runtime_" + "artifacts\":\"canonical JSON/CSV symbolic evidence only, no au" + "dio PCM WAV MIDI playback\",\"future\":\"MAT-SPEC-009 only if th" + "is gate admits adequate independent campaigns; MAT-SPEC-010 " + "closes numbered series; SPARK/Ada and Lean/ECMA after 010\"}" +) diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-drift/materials/mat_spec_009.py b/formal/sonification/mat009/audit/verification-probe-002/source-drift/materials/mat_spec_009.py new file mode 100644 index 0000000..80941a2 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-drift/materials/mat_spec_009.py @@ -0,0 +1,541 @@ +"""MAT-SPEC-009: preregistered-future protocol and synthetic gate stress. + +SPDX-License-Identifier: MPL-2.0 +Copyright (c) 2026 Trent Slade / QSOL-IMC. + +No independent experimental holdout is available. All executable fixtures +are synthetic, explicitly denied physical admission, never scored as physics. +No sampled audio, PCM or waveform buffers in memory or persisted. +""" +from __future__ import annotations + +import csv +import io +import json +import os +import re +import stat +from contextlib import suppress +from pathlib import Path, PurePosixPath + +from materials import mat_spec, mat_spec_008 + +PROFILE = "MAT-SPEC-009" +VERSION = "0.1.0" +PARENT_COMMIT = "b4247877dd471e2e9d4986c86bdc1f11b14e43f8" +FOUNDATIONAL_DOI = "10.5281/zenodo.24062652" +SPEC_PATH = "spec/mat-spec-009.v0.1.json" +IMPLEMENTATION_PATHS = ( + "materials/mat_spec_009.py", "scripts/build_mat_spec_009.py", +) +OUTPUT_NAMES = frozenset({ + "contract.json", "source-gate.json", "split-protocol.json", + "synthetic-controls.csv", "receiver-gate.json", "audit.json", + "manifest.json", +}) +EXPECTED_SOURCE_STATUS = "BLOCKED_INSUFFICIENT_INDEPENDENT_MEASUREMENT_DATA" +CONTROL_IDS = ( + "SYNTHETIC_CANDIDATE_DENIED", + "CROSS_CAMPAIGN_RUN_REUSE", + "CAMPAIGN_SPLIT_LEAKAGE", + "SOURCE_BYTES_REUSED", + "TEMPERATURE_DERIVED_LABEL", + "ZERO_MEASUREMENT_SIGMA", + "ORTHOGONAL_DIAGNOSTIC_ABSENT", + "DIAGNOSTIC_SOURCE_EQUALS_MEASUREMENT", + "UNDECLARED_RECEIVER_SCALE", + "MISSING_PROSPECTIVE_REGISTRATION", + "MIXED_PHYSICAL_PRESSURE", + "HOLDOUT_MISSING_PHASE", + "DERIVED_FIT_AS_MEASUREMENT", + "DOCUMENT_REUSED", +) +SHA256_RE = re.compile(r"[0-9a-f]{64}") +# Frozen eight-output MAT-SPEC-008 baseline reconstructed at its merge SHA. +PARENT_V8_SHA256 = { + "admission.json": "ea1c960c6a6b20a58ae8895345f404d2028e7f3298a25aa871d0aea8e4cf769c", + "campaigns.csv": "5a052673e4c26a5c6cedc46aaabdfd113854419754b1f4ed36c37b9f1adbc16e", + "candidate-pairs.csv": ( + "47df30686f0bcb616a2eb1fca4073d55f6c96f419bcb36e42043acb8c12bfd98" + ), + "contract.json": "d5be6f36e8e931d15f427232268738eea7f2ba5f268f1a29895f4e98048d6621", + "manifest.json": "10d3cde4a68f13facf7badc71bc6e872f17bf632311284943ed8db3c3a913b5e", + "measurement-audit.json": ( + "4f80ef1fb48c66dc7e002333911386ef1ae869c3a458be9b583c8f943b3eac9c" + ), + "protocol.json": "6b4fa2721777b8ea51387782e7707056c0820885a99162dd400892c0629ff9ce", + "source-catalogue.json": ( + "c6d3fec5fc0179df2abbac51219956a6a79af82c327be34b76c359f5ec9de88e" + ), +} + + +def source_gate(parent: dict[str, bytes]) -> dict: + """Read the real, unchanged 008 negative admission, never invent a sample.""" + record = json.loads(parent["admission.json"]) + audit = json.loads(parent["measurement-audit.json"]) + if ( + record["status"] != EXPECTED_SOURCE_STATUS + or record["independent_measurement_campaigns_with_source_pinned_rows"] != 1 + or record["independent_measurement_campaign_pair_count"] != 0 + or record["independently_verified_raw_acquisition_campaigns"] != 0 + or record["physical_phase_accuracy"] is not None + or record["source_separated_heldout_accuracy"] is not None + or record["trained_phase_classifier"] is not False + or audit["available_row_level_calibrated_uncertainties"] != 0 + or audit["available_independent_phase_diagnostic_rows"] != 0 + or audit["original_source_pinned_processed_measurement_campaigns"] != 1 + or audit["source_pinned_processed_measurement_rows"] != 12 + ): + raise ValueError("unexpected MAT-SPEC-008 independent evidence admission drift") + return { + "input_profile": "MAT-SPEC-008", "parent_status": record["status"], + "source_pinned_processed_campaigns": 1, + "source_pinned_processed_rows": 12, + "independent_measurement_pairs": 0, + "calibrated_uncertainty_rows": 0, + "independent_diagnostic_rows": 0, + "physical_evidence_admitted": False, + "challenge_enabled_for_real_measurements": False, + "source_gate_reason": "NO_INDEPENDENT_SOURCE_SEPARATED_MEASUREMENT_CORPUS", + } + + +def _identifier(value: object) -> bool: + return ( + isinstance(value, str) + and len(value) <= 100 + and re.fullmatch(r"[A-Z0-9_]+", value) is not None + ) + + +def _digest(value: object) -> bool: + return isinstance(value, str) and SHA256_RE.fullmatch(value) is not None + + +def check_future_challenge(records: object) -> dict: + """Structural-only source-family split check, never empirical certification. + + Input identity, metadata and hashes are user assertions. They are NOT a + verified original acquisition or independently audited preregistration. + """ + if not isinstance(records, list) or not records or len(records) > 10000: + return { + "status": "BLOCKED", + "reasons": ["EMPTY_OR_MALFORMED_CHALLENGE"], + "physical_evidence_admitted": False, + "independence_authenticated": False, + "heldout_accuracy": None, + } + parent = mat_spec_008.validate_future_measurement_packet(records) + reasons = set(parent["reasons"]) + split_by_campaign: dict[str, str] = {} + campaigns_by_split: dict[str, set[str]] = { + "TRAIN": set(), "HOLDOUT": set(), + } + labs_by_split: dict[str, set[str]] = { + "TRAIN": set(), "HOLDOUT": set(), + } + phases_by_split: dict[str, set[str]] = { + "TRAIN": set(), "HOLDOUT": set(), + } + seen_registration: set[str] = set() + # Distinguish a shared diagnostic *document within one campaign* from + # a diagnostic source or event replayed by a different acquisition. + diagnostic_hash_owners: dict[str, tuple[str, str]] = {} + diagnostic_event_owners: dict[str, tuple[str, str]] = {} + for record in records: + if not isinstance(record, dict): + reasons.add("MALFORMED_CANDIDATE_RECORD") + continue + role = record.get("study_role") + if role not in ("TRAIN", "HOLDOUT"): + reasons.add("UNDECLARED_TRAIN_HOLDOUT_ROLE") + continue + campaign, lab = record.get("campaign_id"), record.get("lab_family_id") + if not _identifier(campaign) or not _identifier(lab): + reasons.add("MISSING_EXPERIMENT_FAMILY_IDENTITY") + continue + if campaign in split_by_campaign and split_by_campaign[campaign] != role: + reasons.add("CAMPAIGN_CROSSES_TRAIN_HOLDOUT_MUTANT") + split_by_campaign[campaign] = role + campaigns_by_split[role].add(campaign) + labs_by_split[role].add(lab) + phase = record.get("phase") + if isinstance(phase, str) and phase in ("HE_I", "HE_II"): + phases_by_split[role].add(phase) + if ( + record.get("measurement_quantity") != "HEAT_CAPACITY" + or record.get("measurement_unit") != "J_PER_MOL_K" + ): + reasons.add("INCOMMENSURATE_MEASUREMENT_UNITS") + if record.get("pressure_condition") != "HE4_SVP": + reasons.add("UNDECLARED_PRESSURE_CONDITION") + if record.get("receiver_scale") != "5": + reasons.add("UNDECLARED_RECEIVER_SCALE") + if record.get("label_basis") != "ORTHOGONAL_DIAGNOSTIC": + reasons.add("CIRCULAR_OR_MISSING_ORTHOGONAL_LABEL") + diagnostic_hash = record.get("diagnostic_sha256") + diagnostic_event_id = record.get("diagnostic_event_id") + source_hash = record.get("source_sha256") + if ( + not _digest(diagnostic_hash) or diagnostic_hash == source_hash + or not _identifier(diagnostic_event_id) + ): + reasons.add("INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED") + # Check both provenance dimensions independently. Different phase + # observations may share a diagnostic document *within* a campaign, + # but neither its digest nor an event identity may be recycled by + # another campaign or across TRAIN and HOLDOUT. + for identity, registry, valid in ( + (diagnostic_hash, diagnostic_hash_owners, _digest(diagnostic_hash)), + ( + diagnostic_event_id, + diagnostic_event_owners, + _identifier(diagnostic_event_id), + ), + ): + if not valid: + continue + prior = registry.setdefault(identity, (campaign, role)) + if prior[0] != campaign: + reasons.add("DIAGNOSTIC_PROVENANCE_REUSED_ACROSS_CAMPAIGNS") + if prior[1] != role: + reasons.add("DIAGNOSTIC_PROVENANCE_LEAKAGE_ACROSS_SPLITS") + receipt = record.get("pre_registration_sha256") + if not _digest(receipt): + reasons.add("MISSING_PROSPECTIVE_REGISTRATION_RECEIPT") + else: + seen_registration.add(receipt) + if len(seen_registration) != 1: + reasons.add("INCONSISTENT_PREREGISTRATION_RECEIPT") + if not campaigns_by_split["TRAIN"] or not campaigns_by_split["HOLDOUT"]: + reasons.add("BOTH_EXPERIMENT_SPLITS_REQUIRED") + if (campaigns_by_split["TRAIN"] & campaigns_by_split["HOLDOUT"] + or labs_by_split["TRAIN"] & labs_by_split["HOLDOUT"]): + reasons.add("SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS") + for role in ("TRAIN", "HOLDOUT"): + if phases_by_split[role] != {"HE_I", "HE_II"}: + reasons.add(role + "_REQUIRES_BOTH_PHASES") + # The existing parent gate catches reused run IDs, documents and hashes. + # Even a passing structural check cannot authenticate source independence. + outcome = sorted(reasons) + return { + "status": "BLOCKED" if outcome else "STRUCTURAL_ONLY_UNAUTHENTICATED", + "reasons": outcome, + "train_campaigns": len(campaigns_by_split["TRAIN"]), + "heldout_campaigns": len(campaigns_by_split["HOLDOUT"]), + "physical_evidence_admitted": False, + "independence_authenticated": False, + "heldout_accuracy": None, + "trained_classifier": False, + "meaning": ( + "Synthetic or self-declared metadata never establishes " + "external physical validation" + ), + } + + +def _synthetic_controls() -> list[dict]: + """Synthetic, in-memory-only metadata fixtures with no physical authority.""" + records = [] + for campaign, lab, run, digest, diag, role in ( + ("SYNTH_TRAIN", "SYNTH_LAB_A", "SYNTH_RUN_A", "a" * 64, "c" * 64, "TRAIN"), + ("SYNTH_HELD", "SYNTH_LAB_B", "SYNTH_RUN_B", "b" * 64, "d" * 64, "HOLDOUT"), + ): + for phase in ("HE_I", "HE_II"): + records.append({ + "row_id": campaign + "_" + phase, + "campaign_id": campaign, "lab_family_id": lab, + "original_run_id": run, + "source_document_id": "DOC_" + campaign, + "source_sha256": digest, + "diagnostic_sha256": diag, + "diagnostic_event_id": "DIAG_" + campaign + "_" + phase, + "source_type": "ORIGINAL_EXPERIMENTAL_RECORD", + "measurement_quantity": "HEAT_CAPACITY", + "measurement_unit": "J_PER_MOL_K", + "measurement_value": "12.34", + "measurement_sigma": "0.01", + "diagnostic_sigma": "0.02", + "diagnostic_basis": "INDEPENDENT_NON_TEMPERATURE_DIAGNOSTIC", + "label_basis": "ORTHOGONAL_DIAGNOSTIC", + "phase": phase, + "receiver_scale": "5", + "pre_registration_sha256": "e" * 64, + "pressure_condition": "HE4_SVP", + "study_role": role, + "synthetic_fixture": True, + }) + return records + + +def negative_controls() -> list[dict]: + """Execute negative controls, recording only expected/observed error IDs. + + Never expose synthetic rows as experimental measurements or score them. + """ + controls = ( + ("SYNTHETIC_CANDIDATE_DENIED", "SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT"), + ("CROSS_CAMPAIGN_RUN_REUSE", "REUSED_ORIGINAL_RUN_ACROSS_CAMPAIGNS"), + ("CAMPAIGN_SPLIT_LEAKAGE", "CAMPAIGN_CROSSES_TRAIN_HOLDOUT"), + ("SOURCE_BYTES_REUSED", "REUSED_SOURCE_BYTES_ACROSS_CAMPAIGNS"), + ("TEMPERATURE_DERIVED_LABEL", "CIRCULAR_OR_MISSING_PHASE_DIAGNOSTIC"), + ("ZERO_MEASUREMENT_SIGMA", "MISSING_CALIBRATED_MEASUREMENT_UNCERTAINTY"), + ("ORTHOGONAL_DIAGNOSTIC_ABSENT", "INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED"), + ("DIAGNOSTIC_SOURCE_EQUALS_MEASUREMENT", "INDEPENDENT_DIAGNOSTIC_SOURCE_REQUIRED"), + ("UNDECLARED_RECEIVER_SCALE", "UNDECLARED_RECEIVER_SCALE"), + ("MISSING_PROSPECTIVE_REGISTRATION", "MISSING_PROSPECTIVE_REGISTRATION_RECEIPT"), + ("MIXED_PHYSICAL_PRESSURE", "UNDECLARED_PRESSURE_CONDITION"), + ("HOLDOUT_MISSING_PHASE", "HOLDOUT_REQUIRES_BOTH_PHASES"), + ("DERIVED_FIT_AS_MEASUREMENT", "DERIVED_FIT_OR_COMPILATION_IS_NOT_PRIMARY_DATA"), + ("DOCUMENT_REUSED", "REUSED_ORIGINAL_DOCUMENT_ACROSS_CAMPAIGNS"), + ) + if tuple(x[0] for x in controls) != CONTROL_IDS: + raise ValueError("frozen negative control order mismatch") + results = [] + for control_id, expected_reason in controls: + rows = _synthetic_controls() + if control_id == "CROSS_CAMPAIGN_RUN_REUSE": + for row in rows[2:]: + row["original_run_id"] = "SYNTH_RUN_A" + elif control_id == "CAMPAIGN_SPLIT_LEAKAGE": + rows[1]["study_role"] = "HOLDOUT" + elif control_id == "SOURCE_BYTES_REUSED": + for row in rows[2:]: + row["source_sha256"] = "a" * 64 + elif control_id == "TEMPERATURE_DERIVED_LABEL": + rows[0]["diagnostic_basis"] = "TEMPERATURE_THRESHOLD" + elif control_id == "ZERO_MEASUREMENT_SIGMA": + rows[0]["measurement_sigma"] = "0" + elif control_id == "ORTHOGONAL_DIAGNOSTIC_ABSENT": + rows[0]["diagnostic_sha256"] = None + elif control_id == "DIAGNOSTIC_SOURCE_EQUALS_MEASUREMENT": + rows[0]["diagnostic_sha256"] = "a" * 64 + elif control_id == "UNDECLARED_RECEIVER_SCALE": + rows[0]["receiver_scale"] = "10" + elif control_id == "MISSING_PROSPECTIVE_REGISTRATION": + rows[0]["pre_registration_sha256"] = "" + elif control_id == "MIXED_PHYSICAL_PRESSURE": + rows[0]["pressure_condition"] = "DOCUMENTED_FIXED_PRESSURE" + elif control_id == "HOLDOUT_MISSING_PHASE": + rows[3]["phase"] = "HE_I" + rows[3]["row_id"] = "SYNTH_HELD_SECOND_HE_I" + elif control_id == "DERIVED_FIT_AS_MEASUREMENT": + rows[0]["source_type"] = "REANALYSIS" + elif control_id == "DOCUMENT_REUSED": + for row in rows[2:]: + row["source_document_id"] = "DOC_SYNTH_TRAIN" + outcome = check_future_challenge(rows) + if ( + outcome["status"] != "BLOCKED" + or expected_reason not in outcome["reasons"] + or "SYNTHETIC_FIXTURE_NOT_PHYSICAL_MEASUREMENT" not in outcome["reasons"] + or outcome["physical_evidence_admitted"] is not False + or outcome["heldout_accuracy"] is not None + ): + raise ValueError("synthetic negative control failed: " + control_id) + results.append({ + "control_id": control_id, + "synthetic_only": "true", + "expected_rejection": expected_reason, + "observed_rejection": expected_reason, + "result": "PASS_REJECTED", + "physical_evidence_admitted": "false", + "classifier_accuracy": "NULL", + }) + return results + + +def _csv(rows: list[dict]) -> bytes: + if not rows: + raise ValueError("empty result table") + buff = io.StringIO(newline="") + writer = csv.DictWriter( + buff, fieldnames=list(rows[0]), lineterminator="\n" + ) + writer.writeheader() + writer.writerows(rows) + return buff.getvalue().encode("ascii") + + +def build_evidence(root: Path) -> dict[str, bytes]: + """Rebuild original eight profiles and preserve their exact identities.""" + parent = mat_spec_008.build_evidence(root) + if set(parent) != mat_spec_008.OUTPUT_NAMES: + raise ValueError("MAT-SPEC-008 parent membership mismatch") + parents = {name: mat_spec.sha256(raw) for name, raw in parent.items()} + if parents != PARENT_V8_SHA256: + raise ValueError("frozen MAT-SPEC-008 outputs drifted") + prior = json.loads(parent["manifest.json"]) + if ( + prior.get("profile") != "MAT-SPEC-008" + or prior.get("version") != "0.1.0" + or prior.get("parent_commit") != mat_spec_008.PARENT_COMMIT + or prior.get("foundational_mat_spec_001_doi") != FOUNDATIONAL_DOI + ): + raise ValueError("MAT-SPEC-008 ancestor identity mismatch") + if set(prior["outputs"]) != set(parent) - {"manifest.json"} or any( + mat_spec.sha256(parent[name]) != record["sha256"] + for name, record in prior["outputs"].items() + ): + raise ValueError("ancestor output manifest inconsistency") + source = source_gate(parent) + spec_raw = mat_spec.read_regular(root / SPEC_PATH) + try: + contract = json.loads(spec_raw) + except (ValueError, UnicodeDecodeError) as exc: + raise ValueError("MAT-SPEC-009 contract malformed") from exc + if contract != EXPECTED_SPEC: + raise ValueError("MAT-SPEC-009 prospective protocol drift") + controls = negative_controls() + if len(controls) != len(CONTROL_IDS): + raise ValueError("synthetic control membership drift") + split = { + "profile": PROFILE, "version": VERSION, + "status": "BLOCKED_NO_ADMITTED_SOURCE_SEPARATED_PHYSICAL_EVIDENCE", + "source_gate": source["parent_status"], + "split_unit": "original independent acquisition campaign", + "prospective_protocol": True, + "retrospectively_preregistered_for_mat_spec_006_008": False, + "training_campaigns": 0, "heldout_campaigns": 0, + "physical_records_assigned": 0, + "synthetic_rows_admitted_as_physics": 0, + "classifier_trained": False, "holdout_accuracy": None, + "physical_evidence_admitted": False, + "evaluation_performed": "SYNTHETIC_NEGATIVE_CONTROLS_ONLY", + } + receiver = { + "status": "UNEXECUTED_FOR_PHYSICAL_CLASSIFICATION", + "authored_scale": "5 Hz per J/(mol K)", + "exact_source_math": "Fraction", + "receiver": "nearest 12-TET note, symbolic only", + "receiver_scale_tuned_on_holdout": False, + "physical_performance": None, + "quantized_source_separated_accuracy": None, + "sampled_audio_generated": False, + } + audit = { + "profile": PROFILE, "version": VERSION, + "synthetic_negative_controls_executed": len(controls), + "synthetic_negative_controls_passed": len(controls), + "source_pinned_measurement_campaigns": 1, + "eligible_independent_campaign_pairs": 0, + "physical_validation_experiments_performed": 0, + "phase_classifier_accuracy": None, + "synthetic_accuracy_reported_as_physics": False, + "program_stop": "MAT-SPEC-010", + } + outputs = { + "contract.json": mat_spec.canonical_json(contract), + "source-gate.json": mat_spec.canonical_json(source), + "split-protocol.json": mat_spec.canonical_json(split), + "synthetic-controls.csv": _csv(controls), + "receiver-gate.json": mat_spec.canonical_json(receiver), + "audit.json": mat_spec.canonical_json(audit), + } + impl = { + path: mat_spec.sha256(mat_spec.read_regular(root / path)) + for path in IMPLEMENTATION_PATHS + } + manifest = { + "profile": PROFILE, "version": VERSION, + "parent_commit": PARENT_COMMIT, + "parent_artifacts": { + name: {"sha256": digest, "bytes": len(parent[name])} + for name, digest in sorted(parents.items()) + }, + "contract": {"path": SPEC_PATH, "sha256": mat_spec.sha256(spec_raw)}, + "implementation": impl, + "outputs": { + name: {"sha256": mat_spec.sha256(data), "bytes": len(data)} + for name, data in sorted(outputs.items()) + }, + "foundational_mat_spec_001_doi": FOUNDATIONAL_DOI, + "canonical": "ASCII sorted compact JSON LF and CSV LF, no clock", + "manifest_self_hash": None, + "canonical_pcm_sha256": None, + "canonical_wav_sha256": None, + "audio_generated": False, + } + outputs["manifest.json"] = mat_spec.canonical_json(manifest) + return outputs + + +def write_evidence(root: Path, destination: str, products: dict[str, bytes]) -> Path: + """POSIX no-follow exclusive directory export, JSON/CSV only.""" + path = PurePosixPath(destination) + if ( + not destination or path.is_absolute() or "\\" in destination + or any(piece in {"", ".", ".."} for piece in destination.split("/")) + ): + raise ValueError("output must be a fresh relative directory") + if set(products) != OUTPUT_NAMES or any( + PurePosixPath(name).name != name + or Path(name).suffix not in {".csv", ".json"} for name in products + ): + raise ValueError("non-symbolic runtime output is forbidden") + flags = os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW + fds = [os.open(root, flags)] + try: + for part in path.parts[:-1]: + with suppress(FileExistsError): + os.mkdir(part, mode=0o755, dir_fd=fds[-1]) + fds.append(os.open(part, flags, dir_fd=fds[-1])) + parent_fd = fds[-1] + os.mkdir(path.parts[-1], mode=0o755, dir_fd=parent_fd) + fds.append(os.open(path.parts[-1], flags, dir_fd=parent_fd)) + out = fds[-1] + for name in sorted(products): + fd = os.open( + name, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, + mode=0o644, dir_fd=out, + ) + with os.fdopen(fd, "wb") as target: + target.write(products[name]) + opened = os.fstat(out) + visible = os.stat(path.parts[-1], dir_fd=parent_fd, follow_symlinks=False) + if not stat.S_ISDIR(visible.st_mode) or ( + opened.st_dev, opened.st_ino + ) != (visible.st_dev, visible.st_ino): + raise ValueError("output directory changed during export") + finally: + for fd in reversed(fds): + os.close(fd) + return root / path + +EXPECTED_SPEC = json.loads( + "{\"profile\":\"MAT-SPEC-009\",\"version\":\"0.1.0\",\"parent_profile\"" + ":\"MAT-SPEC-008 v0.1.0\",\"parent_merge_commit\":\"b4247877dd471e" + "2e9d4986c86bdc1f11b14e43f8\",\"foundational_mat_spec_001_doi\":" + "\"10.5281/zenodo.24062652\",\"research_question\":\"Can a frozen " + "symbolic receiver preserve independently measured helium-I a" + "nd helium-II phase evidence on a source-separated experiment" + " holdout?\",\"protocol_status\":\"PROSPECTIVE_FOR_FUTURE_ACQUISI" + "TIONS_ONLY\",\"timing\":\"Document frozen after examining MAT-SP" + "EC-001 through MAT-SPEC-008 data; not a retrospective prereg" + "istration for prior experiments\",\"predecessor_gate_required\"" + ":\"INDEPENDENT_MEASUREMENTS_ADMITTED\",\"source_separation_unit" + "\":\"original independent acquisition campaign; never split re" + "cords within a campaign\",\"partition\":\"explicit TRAIN or HOLD" + "OUT; two families, one campaign minimum in each; both phases" + " per partition\",\"admissible_observable\":\"HE4_SVP heat_capaci" + "ty J_PER_MOL_K; positive calibrated per-row uncertainties; i" + "ndependent non-temperature phase diagnostics with distinct s" + "ource SHA\",\"receiver\":\"Fraction-preserving authored symbolic" + " 5 Hz per J/(mol K), quantize only after exact mapping; scal" + "e fixed before training and never tuned on holdout\",\"metrics" + "\":\"reserved: predeclared source-family-separated confusion m" + "atrix and discrimination with uncertainty, only after physic" + "al admission; no scores in this release\",\"nonclaims\":\"NO_REA" + "L_PHASE_CLASSIFIER_NO_INDEPENDENT_HOLDOUT_NO_EXPERIMENTAL_AC" + "CURACY_NO_LISTENER_RESULT\",\"synthetic_policy\":\"negative cont" + "rols only; all synthetic fixtures are explicitly rejected as" + " physical data, never included as empirical accuracy\",\"prosp" + "ective_registration\":\"future external registered receipt mus" + "t be independently verified, a candidate SHA alone never cer" + "tifies preregistration\",\"output_policy\":\"canonical ASCII JSO" + "N and CSV; no sampled waveform PCM WAV or playback\",\"program" + "_stop\":\"MAT-SPEC-010 is final; SPARK/Ada and VANILLAJS Lean-" + "ECMA afterwards\"}" +) diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/receipt.json b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/receipt.json new file mode 100644 index 0000000..3a6b9c8 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/receipt.json @@ -0,0 +1,36 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "-m", + "unittest", + "discover", + "-s", + "tests", + "-p", + "test_sonification_formal_mat009_split.py", + "-q" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:52:28.982815+00:00", + "ended_utc": "2026-11-10T00:52:29.350500+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "DIRTY", + "inputs": { + "tests/test_sonification_formal_mat009_split.py": "beb02ce17f07807309e9cceba2a9e0dd6412dc578cc8362050890f38a5bdad73", + "formal/sonification/mat009/source/SOURCE_BINDING.json": "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stderr_sha256": "a9483ce54e9021f19fa52d97950324449ba5ca38db4a3470dd71bef8a85d2de7", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/stdout.log b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/stdout.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/tracked-diff.patch b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/worktree-status.txt b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/worktree-status.txt new file mode 100644 index 0000000..9c54d09 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-finite-001/worktree-status.txt @@ -0,0 +1,2 @@ +?? formal/sonification/evidence/mat009-source-bind-001/ +?? formal/sonification/mat009/lean/ diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/receipt.json b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/receipt.json new file mode 100644 index 0000000..813b10b --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/receipt.json @@ -0,0 +1,34 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "-m", + "pytest", + "-q", + "tests/test_sonification_formal_mat009_split.py", + "tests/test_mat_spec_009.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:52:36.645752+00:00", + "ended_utc": "2026-11-10T00:52:54.847548+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "DIRTY", + "inputs": { + "tests/test_sonification_formal_mat009_split.py": "beb02ce17f07807309e9cceba2a9e0dd6412dc578cc8362050890f38a5bdad73", + "tests/test_mat_spec_009.py": "b6041d67615c4203d435250bdc97403e61ca371e0c8f20f8abdeda69251ccbf8", + "formal/sonification/mat009/source/SOURCE_BINDING.json": "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "d9cc08981d877d35bc68dd5572cb02a6c909d5ee70d9539d37aef89383b86bff", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/stderr.log b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/stdout.log b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/stdout.log new file mode 100644 index 0000000..4813857 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/stdout.log @@ -0,0 +1,2 @@ +................................... [100%] +35 passed, 36 subtests passed in 18.01s diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/tracked-diff.patch b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/worktree-status.txt b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/worktree-status.txt new file mode 100644 index 0000000..40e4879 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-pytest-001/worktree-status.txt @@ -0,0 +1,4 @@ +?? formal/sonification/evidence/mat009-finite-001/ +?? formal/sonification/evidence/mat009-ruff-source-001/ +?? formal/sonification/evidence/mat009-source-bind-001/ +?? formal/sonification/mat009/lean/ diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/receipt.json b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/receipt.json new file mode 100644 index 0000000..9566d9d --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/receipt.json @@ -0,0 +1,37 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "uv", + "run", + "--no-project", + "--offline", + "--with", + "ruff", + "ruff", + "check", + "formal/sonification/mat009/source/source_bind.py", + "tests/test_sonification_formal_mat009_split.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:52:33.144223+00:00", + "ended_utc": "2026-11-10T00:52:33.170994+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "DIRTY", + "inputs": { + "formal/sonification/mat009/source/source_bind.py": "575ab1ea12186419bc6dbae31e12ae1e45d46a3b3c4a630b63e0a53853433beb", + "tests/test_sonification_formal_mat009_split.py": "beb02ce17f07807309e9cceba2a9e0dd6412dc578cc8362050890f38a5bdad73" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/home/trent/.local/bin/uv", + "command_executable_sha256": "92face6b1f0462ad911857957bd168cd4ae45515e2a2cb3fcc3ecbda3d4d82b1", + "stdout_sha256": "82b3e6a6c090a57601d22943bd23fca9218d1031dbe5a7b754092f9a156b4f18", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/stderr.log b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/stdout.log b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/stdout.log new file mode 100644 index 0000000..1f5f344 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/stdout.log @@ -0,0 +1 @@ +All checks passed! diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/tracked-diff.patch b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/worktree-status.txt b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/worktree-status.txt new file mode 100644 index 0000000..f6c6f53 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-ruff-source-001/worktree-status.txt @@ -0,0 +1,3 @@ +?? formal/sonification/evidence/mat009-finite-001/ +?? formal/sonification/evidence/mat009-source-bind-001/ +?? formal/sonification/mat009/lean/ diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/receipt.json b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/receipt.json new file mode 100644 index 0000000..cceecbe --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/receipt.json @@ -0,0 +1,29 @@ +{ + "schema": "qsol.sonification-formal-001.execution/v1", + "argv": [ + "python3", + "formal/sonification/mat009/source/source_bind.py" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "started_utc": "2026-11-10T00:51:31.900841+00:00", + "ended_utc": "2026-11-10T00:51:31.949116+00:00", + "exit_code": 0, + "checkout_commit": "38b5f9e99a5ce3f267c004362acf00ac0dc11342", + "worktree_status": "CLEAN", + "inputs": { + "formal/sonification/mat009/source/source_bind.py": "575ab1ea12186419bc6dbae31e12ae1e45d46a3b3c4a630b63e0a53853433beb", + "formal/sonification/mat009/source/SOURCE_BINDING.json": "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91" + }, + "environment": "Linux-7.0.0-42-generic-x86_64-with-glibc2.43", + "python": "3.14.4 (main, Aug 20 2026, 10:41:58) [GCC 15.2.0]", + "python_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "command_executable": "/usr/bin/python3.14", + "command_executable_sha256": "52e0a13e60a981d8c4b6478be2ba5176f69da07948a056bf49cf6f077e30cb41", + "stdout_sha256": "5a3750fcbab24ba5889a7a5439b5445d7484ac50a497ab546df22139462902b7", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "limits": [ + "Locally observed execution; no author or external execution attestation", + "Input list is explicit; dependency closure requires separate review", + "A zero exit status does not establish theorem or coverage acceptance" + ] +} diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/stderr.log b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/stdout.log b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/stdout.log new file mode 100644 index 0000000..631c1d9 --- /dev/null +++ b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/stdout.log @@ -0,0 +1 @@ +{"assurance": "SOURCE_SYNTAX_PINNED_ONLY", "commit": "0758a96360726aafbb07abed34620eda178407ae", "direct_parent_sha256": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", "refinement_to_cpython": "OPEN", "selected_functions": 8, "status": "SOURCE_SYNTAX_MATCH", "tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", "target_sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", "tree": "a6a03e1227e666680d656b886201ee9dde9de32d"} diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/tracked-diff.patch b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/tracked-diff.patch new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/worktree-status.txt b/formal/sonification/mat009/audit/verification-probe-002/source-receipts/mat009-source-bind-001/worktree-status.txt new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification_probe.py b/formal/sonification/mat009/audit/verification_probe.py new file mode 100644 index 0000000..0715129 --- /dev/null +++ b/formal/sonification/mat009/audit/verification_probe.py @@ -0,0 +1,145 @@ +#!/usr/bin/env python3 +"""Isolated source and receipt deletion controls with preserved raw streams.""" + +from __future__ import annotations + +import hashlib +import json +import os +import shutil +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[4] +AUDIT = Path(__file__).resolve().parent +OUT = AUDIT / "verification-probe-002" +PROOF = ROOT / "formal/sonification/mat009/lean" +EVIDENCE = ROOT / "formal/sonification/evidence" + + +def sha(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def run(label: str, argv: list[str], expected_text: str) -> dict: + result = subprocess.run( + argv, + cwd=ROOT, + env={**os.environ, "PYTHONDONTWRITEBYTECODE": "1", "TMPDIR": str(OUT)}, + capture_output=True, + timeout=180, + ) + (OUT / f"{label}.stdout").write_bytes(result.stdout) + (OUT / f"{label}.stderr").write_bytes(result.stderr) + observed = result.stdout + result.stderr + return { + "label": label, + "argv": argv, + "cwd": str(ROOT), + "exit_code": result.returncode, + "stdout_sha256": sha(result.stdout), + "stderr_sha256": sha(result.stderr), + "expected_rejection": result.returncode != 0 and expected_text.encode() in observed, + "expected_diagnostic": expected_text, + } + + +def main() -> int: + OUT.mkdir(exist_ok=False) + source = OUT / "source-drift" + (source / "materials").mkdir(parents=True) + for name in ("mat_spec_009.py", "mat_spec_008.py"): + shutil.copyfile(ROOT / "materials" / name, source / "materials" / name) + target = source / "materials/mat_spec_009.py" + original = target.read_bytes() + mutant = original.replace( + b"CAMPAIGN_CROSSES_TRAIN_HOLDOUT", + b"CAMPAIGN_CROSSES_TRAIN_HOLDOUT_MUTANT", + 1, + ) + if mutant == original: + raise AssertionError("source mutation anchor missing") + target.write_bytes(mutant) + + finite_receipts = OUT / "source-receipts" + finite_receipts.mkdir() + for name in ( + "mat009-source-bind-001", + "mat009-finite-001", + "mat009-ruff-source-001", + "mat009-pytest-001", + ): + shutil.copytree(EVIDENCE / name, finite_receipts / name) + (finite_receipts / "mat009-finite-001/stderr.log").unlink() + + lean_receipt = OUT / "lean-attempt" + shutil.copytree(PROOF / "attempts/002", lean_receipt) + (lean_receipt / "build-03-ExactTypes.stdout").unlink() + + negative_archive = OUT / "negative-archive" + shutil.copytree(PROOF / "negative", negative_archive) + (negative_archive / "003/weaken_final_leakage_theorem/mutant-source.lean.txt").unlink() + + py = sys.executable + negative_work = AUDIT / "negative-probe-001/auxiliary_named_false_axiom/work" + results = [ + run( + "mutated-source", + [py, "-B", str(AUDIT / "source_drift_driver.py"), str(source)], + "working-tree target differs", + ), + run( + "missing-finite-stream", + [ + py, + "-B", + str(ROOT / "formal/sonification/mat009/verify_evidence.py"), + "--evidence", + str(finite_receipts), + ], + "receipt file inventory changed", + ), + run( + "missing-lean-stream", + [py, "-B", str(PROOF / "verify.py"), "--attempt", str(lean_receipt)], + "evidence file inventory changed", + ), + run( + "missing-negative-mutant", + [py, "-B", str(PROOF / "verify_negative.py"), "--archive", str(negative_archive)], + "archive file inventory changed", + ), + run( + "mutated-proof-checker", + [ + py, + "-B", + str(AUDIT / "checker_mutant_driver.py"), + str(negative_work), + str(OUT / "checker-result"), + ], + "stale proof input: SplitModel.lean", + ), + ] + report = { + "status": "PASS" if all(row["expected_rejection"] for row in results) else "FAIL", + "source_mutant_sha256": sha(mutant), + "results": results, + } + (OUT / "result.json").write_text(json.dumps(report, indent=2, sort_keys=True) + "\n") + print( + json.dumps( + { + "status": report["status"], + "detected": sum(row["expected_rejection"] for row in results), + "total": len(results), + }, + sort_keys=True, + ) + ) + return 0 if report["status"] == "PASS" else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/formal/sonification/mat009/audit/verification_probe.stderr b/formal/sonification/mat009/audit/verification_probe.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification_probe.stdout b/formal/sonification/mat009/audit/verification_probe.stdout new file mode 100644 index 0000000..5d89b06 --- /dev/null +++ b/formal/sonification/mat009/audit/verification_probe.stdout @@ -0,0 +1 @@ +{"detected": 3, "status": "FAIL", "total": 5} diff --git a/formal/sonification/mat009/audit/verification_probe_002.stderr b/formal/sonification/mat009/audit/verification_probe_002.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/verification_probe_002.stdout b/formal/sonification/mat009/audit/verification_probe_002.stdout new file mode 100644 index 0000000..a7ee982 --- /dev/null +++ b/formal/sonification/mat009/audit/verification_probe_002.stdout @@ -0,0 +1 @@ +{"detected": 5, "status": "PASS", "total": 5} From e0c50e1acdf221edbe8d4bc51583a4440ace53c4 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 11:54:38 +1030 Subject: [PATCH 15/22] formal(mat009): checkpoint audited partial results and open obligations --- formal/sonification/mat009/CHECKPOINT.json | 94 ++++++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 formal/sonification/mat009/CHECKPOINT.json diff --git a/formal/sonification/mat009/CHECKPOINT.json b/formal/sonification/mat009/CHECKPOINT.json new file mode 100644 index 0000000..37be795 --- /dev/null +++ b/formal/sonification/mat009/CHECKPOINT.json @@ -0,0 +1,94 @@ +{ + "schema": "sonification-formal-001.mat009-budget-checkpoint/v1", + "created_utc": "2026-11-10 01:24:05 UTC", + "repository": "QSOLKCB/SONIFICATION", + "worktree": "/home/trent/sonification-formal-001-mat009", + "branch": "research/sonification-formal-001-mat009-verify", + "head_at_handoff_write": "49cf9575c648f3c1aedaa59b1bae852a196d5d29", + "main_baseline": "d80f1a09b6f9fd60188148ab20745de5b91462fc", + "private_context_commit": "a1f74e8d1847d218d6b68c125fac9522e2ffc2fb", + "private_packet": "/home/trent/sonification-formal-001-mat009-context", + "source_identity": { + "tag": "mat-spec-009-v0.1.0", + "tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", + "peeled_commit": "0758a96360726aafbb07abed34620eda178407ae", + "source_tree": "a6a03e1227e666680d656b886201ee9dde9de32d", + "module": "materials/mat_spec_009.py", + "module_blob": "c447f0ce76b91acf458221390ac4261166145a0b", + "module_sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", + "direct_parent_module_sha256": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08" + }, + "proof": { + "proof_input_commit": "a09aab6572fb9c3875d5f2940bdb17ec55c358d5", + "lean_version": "Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release)", + "nominal_attempt": "formal/sonification/mat009/lean/attempts/002", + "nominal_result_sha256": "74ed460c20a7ddc98d53891fc3a34de63404169f40405fe08fbcac2e4b6d85b1", + "nominal_manifest_sha256": "c068cb09fa08737a25bf49c17fa7cbca1e31dbbaa5ab388532b5529e1e41c817", + "scope": "Eligible-row mathematical split model and separate validated diagnostic first-owner registry", + "primary_named_model_theorems": 14, + "diagnostic_named_model_theorems": 6, + "derived_consumer_theorems": 2, + "all_declarations_including_generated": 351, + "toolchain_imports_hashed": 1303, + "logical_axioms_observed": ["propext", "Quot.sound", "Classical.choice"], + "compiler_auxiliary_assumptions_disclosed_in": "formal/sonification/mat009/lean/attempts/002/declarations.json", + "failed_nominal_attempt": "formal/sonification/mat009/lean/attempts/001" + }, + "execution": { + "source_binder": "SOURCE_SYNTAX_MATCH", + "finite_exact_builtin_role_campaign_lab_cases": 4096, + "focused_finite_unittest_methods": 18, + "targeted_pytest": "35 passed, 36 subtests passed", + "integrity_tests": "38 passed", + "full_repository_pytest": "329 passed, 202 subtests passed in 120.37s", + "full_repository_receipt": "formal/sonification/evidence/mat009-full-pytest-001/receipt.json", + "full_repository_receipt_sha256": "e2cb426b7ce15ccac76a5959dc9997c30fbb573fa5b17f1dd96f4a5adc0d0d3e", + "detected_lean_mutations": "6 of 6 in negative/003", + "negative_manifest_sha256": "6d99b5c41017d87922ffd01f3b34eccab692806ca38b760299371cbcc0d0750b", + "prior_failed_mutation_attempts": ["negative/001", "negative/002"], + "all_new_python_ruff": "PASS" + }, + "assurance": { + "MODEL_PROVED": "PASS_FOR_SCOPED_MODEL_ONLY", + "REFINEMENT_PROVED": "OPEN", + "DIFFERENTIAL_TESTED": "PASS_FOR_DECLARED_FINITE_CASES_ONLY", + "AUDIT_ACCEPTED": "FAILED" + }, + "independent_audit": { + "report": "formal/sonification/mat009/audit/report.json", + "report_sha256": "70ddf22c27e43059c069565c7e99b7095c29f348142407f307ba92833f7eed8f", + "candidate_commit": "94a357284408e6bc24cfb9b2d49e9d4144791042", + "verdict": "FAIL", + "finding_id": "MAT009-AUDIT-001", + "finding": "Standalone LeanAudit accepts a user-named False axiom and theorem ending _cstage1 as compiler auxiliaries. The integrated checker rejected the altered proof input via its baseline and fixed declaration count. Audit acceptance remains failed until repaired and independently rechecked." + }, + "open_obligations": [ + "Fix MAT009-AUDIT-001 without silently weakening proof statements; preserve and rerun a targeted suffix-axiom negative control.", + "Rebuild and retain proof evidence after changing proof inputs, then obtain a fresh independent audit.", + "Prove source-to-model and CPython correspondence for the frozen MAT009 child gate and direct MAT008 parent; currently OPEN.", + "Formalize skipped/raw Python records, all child reasons, diagnostic conflict reasons and observable status before making wider claims.", + "Review whether the retained source-receipt verifier detects later working-tree production-module drift; this specific probe is NOT_EXECUTED.", + "Update canonical theorem-map.json and MAT009 README after accepted audit; current general MAT009.partition target remains conservatively OPEN.", + "MAT-SPEC-010 milestone deferred under the owner budget checkpoint." + ], + "github_delivery": { + "branch_pushed": false, + "pull_request_opened": false, + "gh_auth_status": "invalid token observed for EmergentMonk; recheck authentication before delivery", + "merge_or_publication": "NONE" + }, + "resume_commands": [ + "git -C /home/trent/sonification-formal-001-mat009 status --short --branch", + "git -C /home/trent/sonification-formal-001-mat009 rev-parse HEAD", + "python3 formal/sonification/mat009/source/source_bind.py", + "python3 formal/sonification/mat009/verify_evidence.py", + "python3 formal/sonification/mat009/lean/verify.py --lean /home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "python3 formal/sonification/mat009/lean/verify_negative.py" + ], + "resume_order": [ + "Inspect audit/report.json and its isolated suffix-axiom reproduction, then repair the standalone trust gate.", + "Commit changed proof inputs and obtain their full new SHA before a fresh append-only Lean build.", + "Run targeted controls, update receipt binders, and commission one independent auditor only after the new evidence checkpoint.", + "Integrate truthful assurance into theorem-map.json, prepare focused PR, and only then start MAT-SPEC-010." + ] +} From 752601f6f72e65392a8c13fabc0ee9e87a02ec7f Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 12:26:11 +1030 Subject: [PATCH 16/22] formal(mat009): close compiler-suffix axiom bypass --- .../sonification/mat009/lean/LeanAudit.lean | 51 +- .../sonification/mat009/lean/PROOF_NOTES.md | 20 + formal/sonification/mat009/lean/check.py | 40 +- formal/sonification/mat009/lean/negative.py | 14 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1666 +++++++++++++++++ .../001-original-bypass/manifest.json | 25 + .../recovery/001-original-bypass/result.json | 93 + .../work/DiagnosticFirstOwner.lean | 78 + .../work/DiagnosticFirstOwner.olean | Bin 0 -> 79608 bytes .../001-original-bypass/work/ExactTypes.lean | 98 + .../001-original-bypass/work/ExactTypes.olean | Bin 0 -> 17840 bytes .../001-original-bypass/work/LeanAudit.lean | 66 + .../001-original-bypass/work/LeanAudit.olean | Bin 0 -> 17688 bytes .../001-original-bypass/work/SplitModel.lean | 382 ++++ .../001-original-bypass/work/SplitModel.olean | Bin 0 -> 529912 bytes .../work/TypedConsumer.lean | 65 + .../work/TypedConsumer.olean | Bin 0 -> 29344 bytes .../002-axiom-metadata/MetaProbe.lean | 11 + .../recovery/002-axiom-metadata/result.json | 5 + .../recovery/002-axiom-metadata/stderr.log | 0 .../recovery/002-axiom-metadata/stdout.log | 5 + .../003-declaration-ranges/RangeProbe.lean | 9 + .../003-declaration-ranges/result.json | 5 + .../003-declaration-ranges/stderr.log | 0 .../003-declaration-ranges/stdout.log | 6 + .../recovery/004-corrected-bypass/result.json | 14 + .../recovery/004-corrected-bypass/stderr.log | 0 .../recovery/004-corrected-bypass/stdout.log | 1467 +++++++++++++++ formal/sonification/mat009/lean/verify.py | 38 +- .../mat009/lean/verify_negative.py | 3 +- 39 files changed, 4208 insertions(+), 24 deletions(-) create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/manifest.json create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/result.json create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/work/DiagnosticFirstOwner.lean create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/work/DiagnosticFirstOwner.olean create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/work/ExactTypes.lean create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/work/ExactTypes.olean create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/work/LeanAudit.lean create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/work/LeanAudit.olean create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/work/SplitModel.lean create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/work/SplitModel.olean create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/work/TypedConsumer.lean create mode 100644 formal/sonification/mat009/lean/recovery/001-original-bypass/work/TypedConsumer.olean create mode 100644 formal/sonification/mat009/lean/recovery/002-axiom-metadata/MetaProbe.lean create mode 100644 formal/sonification/mat009/lean/recovery/002-axiom-metadata/result.json create mode 100644 formal/sonification/mat009/lean/recovery/002-axiom-metadata/stderr.log create mode 100644 formal/sonification/mat009/lean/recovery/002-axiom-metadata/stdout.log create mode 100644 formal/sonification/mat009/lean/recovery/003-declaration-ranges/RangeProbe.lean create mode 100644 formal/sonification/mat009/lean/recovery/003-declaration-ranges/result.json create mode 100644 formal/sonification/mat009/lean/recovery/003-declaration-ranges/stderr.log create mode 100644 formal/sonification/mat009/lean/recovery/003-declaration-ranges/stdout.log create mode 100644 formal/sonification/mat009/lean/recovery/004-corrected-bypass/result.json create mode 100644 formal/sonification/mat009/lean/recovery/004-corrected-bypass/stderr.log create mode 100644 formal/sonification/mat009/lean/recovery/004-corrected-bypass/stdout.log diff --git a/formal/sonification/mat009/lean/LeanAudit.lean b/formal/sonification/mat009/lean/LeanAudit.lean index 897b509..d798ebc 100644 --- a/formal/sonification/mat009/lean/LeanAudit.lean +++ b/formal/sonification/mat009/lean/LeanAudit.lean @@ -21,9 +21,15 @@ run_cmd do logInfo m!"MAT009_MODULE {mod}" for mod in env.header.moduleNames do logInfo m!"MAT009_IMPORT {mod}" - let allowed := #[`propext, `Quot.sound, `Classical.choice] + let allowedLogical := #[`propext, `Quot.sound, `Classical.choice] + /- These unsafe axioms are emitted by Lean's compiler for the two recursive + model functions. `lcProof` and `lcUnreachable` are compiler mechanisms used + only by unsafe generated definitions, never by logical theorems. -/ + let allowedCompiler := #[`lcProof, `lcUnreachable, + `MAT009.initial._elambda_1, `MAT009.step._elambda_1] let mut seen : Nat := 0 let mut theorems : Nat := 0 + let mut compilerAxioms : Nat := 0 let declarations := env.checked.get.constants.toList.mergeSort fun a b => decide (a.1.toString ≤ b.1.toString) for (name, info) in declarations do @@ -34,33 +40,50 @@ run_cmd do seen := seen + 1 if info matches .thmInfo _ then theorems := theorems + 1 - let generated := name.toString.endsWith "_cstage1" || + let generatedName := name.toString.endsWith "_cstage1" || name.toString.endsWith "_cstage2" || (name.toString.splitOn "._closed_").length > 1 || (name.toString.splitOn "._elambda_").length > 1 - if info matches .axiomInfo _ then - unless generated do - throwError "project axiom declaration {name}" - let axioms ← collectAxioms name let unsafeDef : Bool := match info with | .defnInfo d => d.safety == DefinitionSafety.unsafe | _ => false + let unsafeAxiom : Bool := match info with + | .axiomInfo a => a.isUnsafe + | _ => false + let hasSourceRange := (← findDeclarationRangesCore? name).isSome + let compilerAux := (unsafeDef || unsafeAxiom) && !hasSourceRange + let typeStr ← liftTermElabM do + pure (← Lean.Meta.ppExpr info.type).pretty + if info matches .axiomInfo _ then + let expectedType : Option String := + if name == `MAT009.initial._elambda_1 then + some "String → Option MAT009.Role" + else if name == `MAT009.step._elambda_1 then + some "MAT009.State → MAT009.Row → String → Option MAT009.Role" + else + none + unless compilerAux && expectedType == some typeStr do + throwError "project axiom declaration {name}" + compilerAxioms := compilerAxioms + 1 + if unsafeDef && !(compilerAux && generatedName) then + throwError "unsafe project definition {name}" + let axioms ← collectAxioms name for ax in axioms do - unless allowed.contains ax || generated do + unless allowedLogical.contains ax || + (compilerAux && allowedCompiler.contains ax) do throwError "unapproved transitive axiom {ax} in {name} (origin {origin})" - if unsafeDef && !generated then - throwError "unsafe project definition {name}" let row := Json.mkObj [ ("origin", toJson origin.toString), ("declaration", toJson name.toString), - ("kind", toJson (if generated then "compiler_auxiliary" else + ("kind", toJson (if compilerAux then "compiler_auxiliary" else if info matches .thmInfo _ then "theorem" else "non_theorem")), ("is_axiom", toJson (info matches .axiomInfo _)), + ("unsafe_axiom", toJson unsafeAxiom), ("unsafe_definition", toJson unsafeDef), - ("type", toJson (← liftTermElabM do - pure (← Lean.Meta.ppExpr info.type).pretty)), + ("has_source_range", toJson hasSourceRange), + ("type", toJson typeStr), ("axioms", toJson (axioms.map Name.toString))] logInfo m!"MAT009_DECL {row.compress}" - if seen == 0 || theorems == 0 then - throwError "empty proof inventory" + if seen == 0 || theorems == 0 || compilerAxioms != 2 then + throwError "incomplete proof inventory" logInfo m!"MAT009_AUDIT declarations={seen} theorems={theorems}" diff --git a/formal/sonification/mat009/lean/PROOF_NOTES.md b/formal/sonification/mat009/lean/PROOF_NOTES.md index 747d5b9..fcf5974 100644 --- a/formal/sonification/mat009/lean/PROOF_NOTES.md +++ b/formal/sonification/mat009/lean/PROOF_NOTES.md @@ -39,6 +39,26 @@ Python source or CPython execution. - `Diagnostic.first_owner_not_last_writer`: a later different diagnostic claimant does not overwrite the first owner. +## Lean audit trust boundary + +The audit enumerates every declaration from the five proof modules, including +compiler output. The only permitted logical axioms are `propext`, `Quot.sound`, +and `Classical.choice`. All safe declarations are checked transitively against +that set. The two project axioms `MAT009.initial._elambda_1` and +`MAT009.step._elambda_1` are accepted only with their recorded types, Lean's +unsafe-axiom flag, and no source declaration range. The unsafe compiler +axioms `lcProof` and `lcUnreachable` may occur only in the transitive closure +of unsafe compiler auxiliaries. The 144 unsafe generated definitions are +enumerated and disclosed; they are not logical proof dependencies. + +The retained `MAT009-AUDIT-001` counterexample appended a user axiom and a +theorem of `False`, both ending `_cstage1`. The former audit exempted them by +name. The corrected gate does not grant axiom trust from a suffix, and the +permanent `compiler_suffix_false_axiom` mutation uses the exact retained +counterexample. This gate still depends on the pinned Lean executable and +hashed imports for compiler behavior. Source-to-model and CPython refinement +remain open. + ## Open boundary The child eligibility guards, other child checks (phases, receipts, units, diff --git a/formal/sonification/mat009/lean/check.py b/formal/sonification/mat009/lean/check.py index 95e3d44..d5075da 100644 --- a/formal/sonification/mat009/lean/check.py +++ b/formal/sonification/mat009/lean/check.py @@ -64,6 +64,14 @@ "MAT009.Diagnostic.first_owner_not_last_writer", } ALLOWED_LOGICAL_AXIOMS = {"propext", "Quot.sound", "Classical.choice"} +TRUSTED_COMPILER_AXIOM_TYPES = { + "MAT009.initial._elambda_1": "String → Option MAT009.Role", + "MAT009.step._elambda_1": + "MAT009.State → MAT009.Row → String → Option MAT009.Role", +} +TRUSTED_COMPILER_AXIOMS = set(TRUSTED_COMPILER_AXIOM_TYPES) | { + "lcProof", "lcUnreachable", +} VERSION = "Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release)" PROHIBITED = re.compile(r"\b(?:sorry|admit|axiom|opaque|unsafe|partial)\b") AXIOM_LINE = re.compile( @@ -154,14 +162,36 @@ def audit_output(raw: bytes, lean: Path, out: Path) -> dict: if row["kind"] == "theorem" and row["declaration"] in NAMED_THEOREMS} if named != NAMED_THEOREMS: raise ValueError(f"named intended theorem missing: {sorted(NAMED_THEOREMS - named)}") + if {row["declaration"] for row in declarations if row["is_axiom"]} != set( + TRUSTED_COMPILER_AXIOM_TYPES + ): + raise ValueError("project compiler axiom inventory changed") for row in declarations: if row["origin"] not in MODULES: raise ValueError(f"unexpected proof declaration origin: {row['origin']}") - if row["kind"] != "compiler_auxiliary": - if row["is_axiom"] or row["unsafe_definition"]: - raise ValueError(f"logical declaration contains trusted code: {row['declaration']}") - if not set(row["axioms"]) <= ALLOWED_LOGICAL_AXIOMS: - raise ValueError(f"unapproved logical axiom: {row['declaration']}") + if row["kind"] not in {"theorem", "non_theorem", "compiler_auxiliary"}: + raise ValueError(f"unknown proof declaration kind: {row['declaration']}") + compiler_aux = row["kind"] == "compiler_auxiliary" + if row["is_axiom"]: + if (not compiler_aux or not row["unsafe_axiom"] or + row["has_source_range"] or + TRUSTED_COMPILER_AXIOM_TYPES.get(row["declaration"]) != row["type"]): + raise ValueError(f"unapproved project axiom: {row['declaration']}") + elif row["unsafe_axiom"]: + raise ValueError(f"inconsistent axiom metadata: {row['declaration']}") + if row["unsafe_definition"]: + if not compiler_aux or row["has_source_range"]: + raise ValueError(f"unsafe project definition: {row['declaration']}") + elif compiler_aux and not row["is_axiom"]: + raise ValueError(f"unclassified compiler auxiliary: {row['declaration']}") + allowed = ALLOWED_LOGICAL_AXIOMS | ( + TRUSTED_COMPILER_AXIOMS if compiler_aux else set() + ) + if not set(row["axioms"]) <= allowed: + raise ValueError(f"unapproved transitive axiom: {row['declaration']}") + if (sum(row["kind"] == "compiler_auxiliary" for row in declarations) != 146 or + sum(row["unsafe_definition"] for row in declarations) != 144): + raise ValueError("compiler auxiliary inventory changed") (out / "declarations.json").write_text( json.dumps(declarations, indent=2, sort_keys=True) + "\n" ) diff --git a/formal/sonification/mat009/lean/negative.py b/formal/sonification/mat009/lean/negative.py index 2e03b45..bebe4a2 100644 --- a/formal/sonification/mat009/lean/negative.py +++ b/formal/sonification/mat009/lean/negative.py @@ -36,6 +36,16 @@ def variants() -> dict[str, tuple[str, str, str, str]]: weak = (split[:weak_start] + "theorem M009_R6_final_leakage_iff : True := by trivial\n" + split[weak_end:]) + suffix_axiom = replace_once( + split, "\nend MAT009\n", + "\naxiom auditor_false_cstage1 : False\n" + "theorem auditor_false_proof_cstage1 : False := auditor_false_cstage1\n\n" + "end MAT009\n", + ) + if sha(suffix_axiom.encode()) != ( + "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71" + ): + raise ValueError("retained auditor suffix-axiom mutant changed") return { "drop_cross_conflict_stickiness": ( "SplitModel", @@ -67,6 +77,10 @@ def variants() -> dict[str, tuple[str, str, str, str]]: "\naxiom fabricated_physical_admission : False\n\nend MAT009\n"), "LeanAudit", "project axiom declaration", ), + "compiler_suffix_false_axiom": ( + "SplitModel", suffix_axiom, "LeanAudit", + "project axiom declaration MAT009.auditor_false_cstage1", + ), "prohibited_sorry": ( "SplitModel", replace_once(split, "\nend MAT009\n", diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/build-03-ExactTypes.stderr b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/build-03-ExactTypes.stdout b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/build-04-LeanAudit.stderr b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/build-04-LeanAudit.stdout b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-04-LeanAudit.stdout new file mode 100644 index 0000000..20a4ecc --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/001-original-bypass/build-04-LeanAudit.stdout @@ -0,0 +1,1666 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"False","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.auditor_false_cstage1","axioms":["MAT009.auditor_false_cstage1"]} +MAT009_DECL {"unsafe_definition":false,"type":"False","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.auditor_false_proof_cstage1","axioms":["MAT009.auditor_false_cstage1"]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.initial","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._closed_1._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.initial._elambda_1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.initial._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.initial.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Role), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqRole._proof_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_3","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x y : MAT009.Status), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.instDecidableEqStatus._proof_4","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprRow","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._closed_1._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprRow._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.instReprStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.instReprStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.lastRole [] x = none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.lastRole.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.lastRole.match_2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.lastRole.match_2._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.leakageReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.leakageReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.leakageReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.noParent","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.noParent._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (x : String), MAT009.noParent x = False","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.noParent.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout ∧\n s.campaigns MAT009.Role.train \"SAME\" ∧ s.campaigns MAT009.Role.holdout \"SAME\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.overwrite_retains_both_split_memberships","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason ∧ ¬(MAT009.finalize s).childReason MAT009.leakageReason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_can_supply_leakage_reason","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (reason : String), s.parent reason → (MAT009.finalize s).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.parent_reason_survives_finalization","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State), MAT009.scan s [] = s","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_append","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key ↔\n s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_campaigns_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), s.crossed → (MAT009.scan s rows).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_crossed_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.scan s rows)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_familyLeakage_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key ↔ s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_labs_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_owner_last","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason ↔ s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.scan_parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(MAT009.Role → String → Prop) → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.splitIntersection","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (members : MAT009.Role → String → Prop),\n MAT009.splitIntersection members = ∃ key, members MAT009.Role.train key ∧ members MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.splitIntersection.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"MAT009.step","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"declaration":"MAT009.step._elambda_1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"MAT009.step._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key ∨ role = row.role ∧ key = row.campaign,\n labs := fun role key => s.labs role key ∨ role = row.role ∧ key = row.lab,\n crossed := s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role,\n parent := s.parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"MAT009.step.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String × MAT009.Diagnostic.Owner)) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (x : String) (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_15._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_16._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_17._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_18._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_19._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_20._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_21._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_AUDIT declarations=353 theorems=96 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/manifest.json b/formal/sonification/mat009/lean/recovery/001-original-bypass/manifest.json new file mode 100644 index 0000000..9602bce --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/001-original-bypass/manifest.json @@ -0,0 +1,25 @@ +{ + "files_sha256": { + "build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.stdout": "1383254714bf4ce3d9cf3d50c98f8af57f86e59b1b0caf36a09ad6192b8a9167", + "result.json": "ffa09ef35737b0d257f41da6dfddba8add0d14ce86b77a313e7fc4689ecec44f", + "work/DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "work/DiagnosticFirstOwner.olean": "08b4c6e3a902aab9b14d745d84e34195891f5e82b4aeb620c4c97924098c3dfe", + "work/ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "work/ExactTypes.olean": "b64b65124db21c2a2c958e45b5d199f08ac83b4c6ccb853c27dcf492c89b7525", + "work/LeanAudit.lean": "7aeabffbd65357e4ea41d773950bc7b52c892c5347b259f51d6a3831296aced8", + "work/LeanAudit.olean": "984a157afdad5b791a72af945e86c797d56f59927a2ad69c265651c5a0e8fa6f", + "work/SplitModel.lean": "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71", + "work/SplitModel.olean": "f8578979fcf795ac9ac51bea1cb32e9a766e7a1ee32e9082ff3dafefd1b5c60c", + "work/TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa", + "work/TypedConsumer.olean": "7dc3d93ec2f41312cca1fecb0969bb079a87ef62468260346e99a5364d8cb0fe" + } +} diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/result.json b/formal/sonification/mat009/lean/recovery/001-original-bypass/result.json new file mode 100644 index 0000000..af0c50c --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/001-original-bypass/result.json @@ -0,0 +1,93 @@ +{ + "bypass_reproduced": true, + "compiler_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "false_declarations": [ + { + "axioms": [ + "MAT009.auditor_false_cstage1" + ], + "declaration": "MAT009.auditor_false_cstage1", + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "False", + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.auditor_false_cstage1" + ], + "declaration": "MAT009.auditor_false_proof_cstage1", + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "False", + "unsafe_definition": false + } + ], + "jobs": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/recovery/001-original-bypass/work/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/recovery/001-original-bypass/work/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/recovery/001-original-bypass/work/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/recovery/001-original-bypass/work/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/recovery/001-original-bypass/work/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "1383254714bf4ce3d9cf3d50c98f8af57f86e59b1b0caf36a09ad6192b8a9167" + } + ], + "original_scanner_sha256": "7aeabffbd65357e4ea41d773950bc7b52c892c5347b259f51d6a3831296aced8", + "retained_mutant_sha256": "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71", + "schema": "mat009-original-bypass-replay/v1" +} diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/work/DiagnosticFirstOwner.lean b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/DiagnosticFirstOwner.lean new file mode 100644 index 0000000..7283ce6 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/DiagnosticFirstOwner.lean @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some first + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/work/DiagnosticFirstOwner.olean b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/DiagnosticFirstOwner.olean new file mode 100644 index 0000000000000000000000000000000000000000..c37c782169014dfbc0b84afdb41183412032a707 GIT binary patch literal 79608 zcma%Ec|cUv_aF9ATyV!F8!MAG8+XjKaY@lM$)(1u90YW50R*(MEYYkmQ)x5QGBPz% zD{PZW6U~aUlG1cEE6PezE6UW-`s(kUcR!!u^1yz*KRCR5K4-n>-gn=fH*Yegr6#3^ zhIH@TrFUni?ZQXTo0{KXa4p%&n+B(P(Y%;vTpsSLZOAU2snF)idWd; zM?K(3?Kq#1nUyvxDJK=DCei&#fS$?wZc4o5!|lrjAo^NBfV4Tz2c;!VPS42BNlPA_ zmX)0|^6vE1EU;{%*9UzCpeNt_aZH0XbCU&Q@I%YdZrCu7ic9C8{Nva3TjfOTMyX~S zX(Y}^^dIAN_EslirwV#vLRB7q9C0oye^v2JL5QAc$dT5^dA0v&Fo@`jhaNZRj&nC2 zUU2wCQ$dM7)(m$JjH`{Y4q!{_l~SH`$giT9#ZO? zker>9G&xl{W_qXed7&o{v~X+52l>k%UP60@PV->@yxTZ=$n?fv6_f9W9P|Bg;-1&m z-FeS6;s2XIS*erLvg?R10DZCHD$e86p4k!^cYGb~C7_-D_HTVA>&J*YE~h>AD=GUo zbp|@c07@Q%dZ4ev-^;H#-M(Ta^~B0Q#zERjo!aR4gp3?-YSx6bl+^T`w4B){SM<{V za_CJuI`WaQdixFwK2wx50H{KvLDA^wToSkx2k z#--fz%pEVx|JlmVLw~LRZt<+XyEX;uDN=yOLCQE&r)Q$qYxb)jeoS9>*RLP0eDhh6 z6+diI%0Jp^&_3tZi~n2}jK6^Zjf0f)-GrIx*-4X9CuF6XL)^sZ`E)_=qo1sAw`}3B_mqvu>`*czJl>&Qbe?Z-6d1kBlnf# zWj^27cF*&fpMSENd>7<6Z;idQ|DxNkeaf7VMc!fI_dNJ{W$*WXx`Fb{59OB)ntJ7` zou3S@#YY{_Dww$B=AFx*B%k$1|6(sWIOVR=@6F4Erz+|FYzl z>6a9Y6@chxzmc;4CS)aLQIp<3KIplASWe)k=+fUrkMIl8&ip)kxWO$Wk`6AU9bQjK zgV)vUndy@PB8l zL1Us-{~|vZT#wJJzKomwX5`X55*sM_tOJ+ay!QL&wn<~G(GNbf6DRG){})`JPS40m zo0TdkRTq>ihMsx#m;IbH^7W&_7d>3hlM?R}01l}Kwg;f+MCzOGWMw_DRUo1#3|La? zo8SV&Afm_7P{rv2eQ4(`vntDOND`Fry=dpU-IjlQ`!746xJUS6hvS2k*Xs%1*&HsW zo;>I&0{wB}J->fA@auPAC$t>xFG+)O_~OpKJ>0|X<7o;PPB75B+4-+#Y0;_n5*m;N<$nFpzy7;@om;C-OEQGaw$$bYw= zn3WM6%ewty=$U=@n$N$P<=iW}bo;a;?PA{#d;qlER@_f`au~i|u>MBpWCf={-M+K2 zia&CGy!{IALsy9&GfuP{I?bc}hE+T8uka&c!1sav{g!Jcu_DiL%(m|)eDJm|UjVrh z(8XH^on>u`{(Qve2Y-e8t!}Jg<9;}tqG-P4WR7j=Z?3O0pNFzcZJqsCn=p+Z(_F>Ry7r#id_G*`J0a%;ZqlY9>m$GyyY%twp1+#gVygX3 z1U?fq?DUW$k(%CO^h+N2eHZ@TKgy%zW&X(rKY)0PfNRj`j@9-=h2vkrCjigrOqSI^sqsn%_{LRDbl;po0?S9lrS?v9D!r+Yb8|S%;J8XZ- zhPn~Cm{uwd*5{=6tEPv5Z{#(S>pRw89Pmlcp4u4h67Q-H(N_gO5`cT{>|1*x5)?-G zKD4t=+6*``DN^GXfX{K*$+P{hDDWlE9N(mzZ@sBW=3FY43_HQ=iXZwqojv~PO-r8t zntWTViks`!9c_+2wXWTFr^t7J&vomQn@+x;{Mm{!@?GF_Jz9G4#XtM*nP={s8TLax z;Qvnqj3fE*bsslb{rLj<|KH-sNvgh(>v0r9U;I0(_N>2Q@++c8_+@Bk91FW_>i_T| zr@0*={7Uc{$Gat8{n@V|@FeB!tyLZvN820bt{5Bjp_yKZBM$uYB48Z1)nC%~^CLIS zm;XgS=X=(3_kQ8t`zkIn_iglg=6nyia4+=cf!b}(zx8@9L_6oD!`@H+39*Z`X*Z%2 z{1VjrQ!}>S8w$SEdqV}ao&Iuqb6ci5G5n3-JkEM=?2g_Zj`>0Ov29d7Sbsgczc?wv zQ7vx+KOXeclb`R7gnoUza2&dUyS?j`#1QYS ztfOwX+;aT+cU(QlPXwQJbfW%mBgS<<{~7q9nc#C^el?-Z|2oDEYb5-Ciz7QdMIh!O zelU(==<9v7y=TE41>FT8d_USb9{$?wY4Xpq4nL6}0H1N(o?QRAPF*K|Kz?kyn&aW} z#9ofkUpF>qL_>dQJosU7q*2P@%01UFHtXHs2j^4v*Uwv%)^a`-z7O)OzXztjaZ#wL z-Sj`A0DR7m+vYTE76!i5mm7T6eF@GN4l6%wosR{dk9awb{J>wF{Pts9zewzIh<|0M z5Bo(b51CPi9;}ag6MYG&*8s*{JaCTX%^!_+D?R)x_*~3C!SMk6z>9`NHAo;*QL$fw z`8p4{-_oA_rXg^m&$^B%0dDJ@8J{(Zuc=S)g_d=MANX%O&hOqht~TDfjAmzL}!B@QzsOxbe>xF?Mu7(6_55z&>tV)`-Jf1F!&L9Xy^R& z^baq+M;*d1qCD!g3o#X#CKa4hG=o*gU>jA zAF_60s97zhd#U~z^X^;HV6J)nlsuPHKjQr8p`nlI_L)asm)`66zd@mn>O96= zs^a2(+{W#{R))E%`Bl*G1n$n)Up>a_jpWCR{Z&5a@=Nx^Yga!J{<3J0JaZ}}<^54& zR_e5wDXQ8x=`B(y(IcXW{HcspW$3gsMDsK~xZrT#|!}xy$ zYw*K8Xy<+0)31HITX=F9{D@reOHfy>$A=F!?3;&NR|1G57PvytPksJ7BU}K2h`vPN zOMxrD{KHm}zzM$!?X15R6Pl()Rr7;+JAk}B+tGjIx^}+==PS;0q?|`?&IoRE)yPX? zN0pbiqj&XcTe|RPaaHo-Lpx*r^^4#73QrF4vjBYd&kgH8dY=6weD0TUoV>i{kMBY} zrnqq(4U2R_z68_{dhF%{_eCTs9RG^G81Mt29j9L9=e~-;59Z|v@-pJ)f3AP%(dKuE z4kLztyB-8LIt@L+dhuSa@)9!px!3HM&RZaQgwJ~6_@1)-%ki_`@7G88`uxgzf?Rkp z^p%57Pq?neet9L@S!aDFP8q=5OMLv?BtsM$$BNa%7w-D%i+kmN$!A0=R_a(6R5`r{EMm2e#P2S+LS&!_ywT*{r}s;Yp>WV zv)DUVko!O+?EPE+WM@ndUSjq9+v8Ncn{7KM71IG7t!j=xz+HTV5#vmAPUY}YJf z_;pwBLL4ChwDbPx*Yy{@cD460vz{dnu~(@0d4Duyb9$gnmoDZiLHP0DbN+3-bIgak z8@zD_`a|8|FGME}92!5l-`k__0za4s)<^5C71_L=OMUnt&pa03eEL^?7cge1wn^TL z5l;zlo4i+a;rNZWh1>H{|ExF82bI8gFACpQ&qIxhiXRD(<2+=)Qsw3Q1&-h9*D;U8 z0q+9tl?hk(hz3sl$i+Iuj_YVKuh+m2D(y6&fvdJ3@sRW3I*|{2-j(CFH+0s<*V_LD z-hbWg7dLX$##`6r0pMRcvLUN+Ol`b%T^@Ip%FCJ|W9wPq=DcNHmy1TZ->Jg-+zolw zZ63~b%W}U{sI^PK=V6`0e%-w9>f1OU8T@cQZ$Q1LN}q91r^wr`R(^B6vomt_f)JNN z2;TuduQN|Rer{N(#&?0w_0$y`yXA#xd=L1nbN{|EBlYW81>(sC?ytbc+jw0!e7@j# zHy(&nP8xp=KZDnmQs`+M`t+&37nPn9kmR9~ejs08zB}+B6-b=+Yg8VX$1W9(FW2%I z5eGik&y5FsbEUq1ZV6?id|oFlJv%3OFLUDz{bS@BetV(+nSu_>ZoPThM*3Zdb|V+& z@!O>4=DjKS5vAZWzgKms{7PR>SAfs{d-%&uH)`wYhy?I$omKqT9=oEP`yrAyhh4Sv zzGe9zWy9f$_#fed9Itonx`tfO`APV!EBbfrx0xQjzC4i61x@YT@jljv5%UF~kg%q2u$?wT1m?5$Jh%zr*6Mi#r^Y`DM!bD>B|#6k`E`^4V~t( z>6dq($G^f4&g;x~j`RAJ%(u*^mGCbSdNM)hZ_Do%=Ab4;MPDKC`M`ZWZ|8^l_=toE zDdRIA3j-E6iMdhdX;u{}qV42_rZ@nJG13xRW-zM(CQ@`xf@HsNpkr#Nu7;P7< z*R0e@!G(_WEB6&jAfFI9^-bG-E#4J920y$4?Hs=$P5PL7wBSeBx~jN1@9pdU_Y?ZO z=K!Dc^A!`uT*mq{;*PZTgA4eX*Tj_b^Ifqehv2RK-~m2s{bYZX!-NI@2;SNc`M@7} z#<{8zlQtK&VFxw zN$yqDV8}-Vz~_4E-1vH5&}ZStc31K8x<0<$^-qU7lm_9)gU@;H?){_g(f6Bd7{6TS zU*FJve@J4rybtocKHS=L;9&hepul4PiIf+Xg=z977W<7yf6zQ!<8xi%2kv;{d&79& zEB@0j`oCyt`}w+m0m#MnPW4|&#CkFg`phPjjm;d4C~0PgeyJCeBW5I)yc)F1iai47s> zC*jBUQt?y&ljlyH4b}9=k`MahTi=Z1yeaY?Tpw9qv!?HPMz7xj$nm;A?ez_x>-Ad# zKCizk*MD^z>r?dm!1sd|c58eO@1unuKs)UZ%f7c4?-zy7@e>=b;vBIxp=mwTzwqPH zPWiu+-fYDCLE)D$|G+)+Zp)Lr50rZ0dWAGXb&V}2D=GLum!T(keJg;TXX8FR8dEg# zguo4ccq!UB&-KU}^*B@+_gx|Uc+&RFzP88MF8)`t9^0;qd{NqY{zOBzsZpf2=`ra=;)%!Odd>`oKHr;nNKz=1Z%m*pgt7Ej0WcU$W z_m)7<%`GNBFstFaYnY!3v@^C9@BXzz&qD$Dw(C?L+C_bQu%YG$ubHIWw>F-;o1E1@ z_$a@rQuoINeOsEeJn{MX4VMW(-@jvjNxLBzo(X(D=%yW)xr8T&;%9#~pZU!5dOdSI@IL0-TW22*i>daH z`>~u4p6+)^iw|gZp=^7>0{67^JX#loY(Fx znzCA-*UG_XKTf}NZXxG2$qVb4l=WOkI%?!2rmu?o&$;72n!n+qw&Jnm!-aN3w|Nw0 z=LJ6O{mu1wbHQg_?H|~uLXWo!@e~5LW7qUOdfocbPo?1RY&>NK=Mk~* zK;2h>zxn-hdm3ruoAHxIAr2!S*{RbenP-NcU|l%+sXSCXInjUa_l7SCK=P1)cGkrc z-@Z|!F1+BgE)IPe@7L=h4}A7p&-?cG)aO$h_(h<7eI1`yPot>u;KMv!2L79moPRn7 zamx6zuGcDoD|Q~ZwTa6NGx$gF*7chG1{L?oUV&jvok6JikKnEAwRqrrG;Oo9nWHw| zx?b}FU-oV9N1J0_p_Dm4V4u(hS^)f={$*3R*F?O`v)1*R@MImAfa`J@m;0I+ zmx@!)jhepTb!bAy#3_Q2L$41P;XxSDDvvIT1Uo1ybUY z6x{r)+bM#+(}~HmhjrLx-V+PI9PQlK@7j3vfF*O!nUC!WzY2Wr>+j5td2n%bBi=8E z#PnD3b6>x_?~#KggReF}_c!E2o#0;#zs5B!EqQfY+|6=o^ixzK_<68Hx_4&GKE?!5 z6VLDC5SI!0ht|8ZnF}4ybvyBez`ryqWg@S4#7lqk`)RaY4!mHDc!JN<@^iDYIqBC` z%Nz5@0F@8k2QK#d=Y}{G!jO;P`k3?Agtz`k)7Qx^$a_G)x#GiPT&L^nfeSqsSqQnY zT?@@MjaU}DB^JN-4%zloh(oxF&-+h4r|8N;8LIJP2dcOk*PvgU z9S^JKhx2=Q%KgFE>*4TMNvZu8J~u}>Kk#dccPxm2ejU%}=7^6Or1J9VJBv5+ zeuH?4%a6RefID*k-1WRZoAYXGB~N{sz>PhYw}|_H)F*g8H%ELv@V~BYFuI9OZuENqaudgI zT1u=zFE}3$q7s9O-T1*OAJS~xZ`JeQ{HwQzen6;M7tItd6Z|zDM~&uuCHxZbxgYiE zWnWF?{3rf!UxAeS3j_O)NbEm!$juY_)0*o@rIr!t{+Lcj!YOie9*|TV@y?&Cokk_FCXVWUHw*^ZZCm;fZn`r^Y3-#sf7BX zUT#rWp8VjuF1q6@=1JlSu)T?jH@*AQP3W`m%aNDZp^Cqu)8&U4oA6`NPx0Wtbl=+_ z@t#8XZnU%BD|`HQC;LM9yr1*|*L?rNr`Tu0FKDdnay)cDcx4>NgYXmM6u$)W*Ys%7 zko_TiKiXMG&aLA%>-i}FKLC1Y`rfA-paW#x!0)pgHDw;L!<0Qa5&hhMV|=g7IJ!dj z&ka2Je;?nsQTLDgZ$99v-oNMyy??p?M)`M#`47++v0q}*Kk=f$pXv4s!1sfG`f0*2 zJ$|kaIREv#CTW|lKlUaSFYWJ|mRIBZwejFHzc+u_WvQ;;ZIS=F)4+au{c-=#2VB49 zV;1Z6m&yJ`o#r-pu8R8QI%fSGu>^WnE@^fh?Wmqp{Z#)i|7mm_9pSJ#^{@1dRb_~*-2M|r(8 z`y2NyMZlGwoVvde0u+8M_OZy{_GORRI-mW_{`|h*#L;?xvp?)3R35&4cKuqt9@!u4 z@9FkGivF!X5}>Ea^hdYX)gN)-dqMA9x3ot87oeT}@z!szzM=OQ{Vf6R^2T{5_5Sjs zo&6nn==I)ue+4Z1TkT%`WnKLhd$Y>N-c2FpdVj^Eo&D9W$5Z3={;EVjxq)kY^2Tc$ zYyIUzJNF%9reE3u%VTqX;eMSLdirlZ@73*>Kt2}q_VNK|bo&X|7omTv27R}Y&%??1 zvF^78pvO^p=uwVCef;=oZ=}k{)!DCJrq>tulexd~_@xyu>GP2na*SvE^Wz9 zA>Q*FANfU(rwDw;yXDRIM$*1f$7i^|N6K94`+YS(g)!%a;J!{J^dH!_eD}6tCnrnn z#<&W1B&vA1uXEq8r}Ol@xWH%J>&F}kt{r7udcgN#{&@J3zbo`{l?y)S>5ulMKFV<= z@`d0tFS~LFe4^KJDfMGs`|0W<&+2vT#Xb+OqyId#;5vQW+ipR8xSoGs{ANSF-zuQr z0bHZ@4VvivR))N}!0$ZHenPKv?n^U24PT7jqF)C&uW}ss96Z#akK;n<<-D{duXvOm ze=hi?pkKWBWwsuF1=^{9ZoAN-y8oOl$Ys;PZPFhA~dPo^0Ufg0@)k&1?ENU_CINGr!*bI`xRZ<&a~(wne0Q z^?X%F9h<&sQ<{F{4%7v(ATgi z`~u7)nc!cxd)zNNrL^T{@sKf&vV@be*84BGhp^_!a^fx<7t{80}6kB{`J z-yD3o-?XmlgeB{}c#O{~$i<9N@eAKrw}-}Q=cb<>6rcN%f6qC4jXth;f64uggip?` z3~`AzwI1<7AHVPK|7@K<%4M=;-idI7UjX`9>jRzbIv@A1o~xA~FP$6nY`DhvLymRr zes}1w2#sF?egO2VA7}Te2fk6awca-nJ674bK5}bM?kCuA2;RD191r}kh5x)9?I2Q7 z!PnaV1%62L6`kwYSE%)TQ33F`w7Py7#|N!QfAT$4?2|I!1ta;jb*EfpY)_oblTl3=ve$O3!_SbjNb43Mj%}*Ziw_m!s zV>AaG#01ZMQPyJ#@L&4=%;S7VD>4qO`4OJvEr2{#LO%93l?UO=IB;s`M!qiieV&<_ z@)DJ75tDoeud^P=e>HN*bKNms1*V9efg}Fpp^=BE{ z`JDJ(cT%K29ylKP+)K=KKKI|JyzszY;mINMfCGF#;*3w9zlyem&-s;gVZrkI6Rk<3f8r?$`6Ljk+WPe7$Z<;fDwKZ@XPF z$hv2jOS~n%Y{}D658C^#m#6WK)a8oZo<7oh#^ivc}kTSXI zx~7;$9Kn8yzf0xmM(6DLPql6Mg&_X5zr8SE5M56$^t^t3@4_y+Ip~g72VLb5j!rl>$T7+d*%Ts^c1QqA( zqc1Pv=WC{a82|JyGwxJ&sHa*!0dii@(U%1#MnJzlPuRiF1N~*um>H4KqqM2dnXUa@ z1bkYHhW}$760hfv@m=q{VS)a6DC4txRD4Z_3>~J&ABT4OKYsJlm5g83Q$}B#2d^V? zV%QD7-^L61gl>y3RY=t@xoGG8`K1f*bW)f2T?js}<74-|{51S8s7&#>-I$P4}U~z{6hF$09;i?#phArOFvuhr%He;`{sjtS!XsJg16pJ`GJo* z-{-A*xkM@|@w;H(o}%)Q{lKrzhQNtFK2Mc^`iTc_=8SIsMwvDBnRR)w(!={RH}F4x z@cze*J+<*gn6Leu4}o{JC|bnlx+rD((^TmXV4Ye5ynCi+MH3g1iVEIC{lHfO|6IM@ z(bng?Bpjp4xcpI4%T!cX7LK>!V&MC3)m~6d9-R zj5vbtqp^8ayh~q*yi2f_XpF5M|o6a!jDCJ3FyAjYofIG#f7`<=uhyk?2-Du z9$x_Mw6iSiy01g9CN=e^DS6sou=C8KD2*QvKCdgYCmcMl*^h98&+(klw^IYYuTJ#) zVc!SbGi{fY@%>`L_u#&Q`MvTD@AgpiukcGC$Nc^IlD}B*p91jxpeqh;c{CdSOWpDP zVdbcw0B|kB7G2uFt@6yjf-j6w`EURqJ4Kz}pR?vNzL!kLTgO2H@JAM|np?;F$!d)Q zAMpRX`}6PWct2UK{nH}gXXHM5YaQ<=i?Y6-%n$s$)|dWneLtDZGkkA9-*al8ih44F zH2V+tPt4o#?Qbq^pw$Q0+3f#S&%V5#>un>S!OtIgz4AeS)x!ttaesmN6nj-IQIEh) zN<1|@LbF$fcGm0OiQ95mug2KF;B&k)E#H53Vji?lQ}%9q=fn*Sen^4~f7v>(;kHh(jSHj!O8M3I4=WOJ3E-4cAM2ujJ{<4sntBN?y+!*SE#c zlkw|{*_?+JTJ;m(D_IWQrao`IX3wkk$2MKXNxv()^n9hB#&>|v_W%~m>3^g?_~MWC zJ%BFY8(eeuiD(}^srH}GGtz$#@V8Cc;bi?#O7fKtzw?26!`|kFhFZUK9w`O?>Zk5q z+eqVApq=x;m48OfYOL|OPhm?}d3dJll;W6be(?LlyiSB3Ztc|PQ5WP&FrWQ?L)U$J ze|o^D{jtmbnyb%)4)Ak92R+>VWRq(95pL8=A^7FXTIM$eU-ECA$4Y@4dhB>av)c1m z@I8o}$0~q#wDrtrp1{mk_m_1Zi^))V`mFHJ2`%DlK!5iufFeMsGM-N1Fy_%n}9=DvjJv*y(Ydw(sN@g_fKqDH}6^I8CW#M};T zxqqqSt$8g2{=l0Xhgm;w5`TFeuLM|_`I%#eeP;gAAIr0dR>dn zQSpB~{N-1p6X=Peg127R;(_nb=I9#@&@Yq{|Gcp81#ZD}Mec^c37_>`0RF=pHoLiQ z6n+WXneV=RKHuC}lV^SSfgAhEC&e)u--UTU4&&lr-&Rq2f5*;L@lyYfw++nF`#S)= z@xaag^5UgUH2r?mksJKS7oOeM6nx2-b-ek2+xo=eFPhaJZ^7#p$6EpLALgDfZyw9c zR`-W>yp;hzZ`y?T7MAfQ*9rbUmGwGNf;a+@kDI0PB9`Pj;nL1!+*;o^Rf>Hd!AsoM zeFnbYWmHt@n{~|Nwf4F4VXth<;sWbDF8ZzWekt%z*UxG8U!EJN0={tfmrJbA4H%cX zP`yp^W{p?H8E(sj9>?7(Ux}a|P(9B^9z%R+7kQ(;gYP5kA`QmTXk@SBEARc`Uin|@ zKlnUrbESXNpSIsaa2*yt_n-aH`^Pmm+!qGEVf%vj1L+y*sbWJ8Lr?I1jIlmt=c%kq ze!S`Zr4N7~?m|01hui$^rYlWhB_H7dzofB}pS|;o&W3&SFynxKxxl@0d0|{Q{51MA zsswx=-^~c{;qm5GF1tazxU6miq%bZK{Z(v@ee)wD{?ZwPi_|vod z1;3|3d(!__d&*9jtqOLXkoSNJU&f73J2(6aey{K;C_fSSeeL?g3r@(X=o0P?_n z)LR>^a`71eh?;ooep?yjx9)iB<+}35-=SmP0yX^$?x*lM(Db}()@b%3t?vu}H~*v` z67ErX^@4V@Eon)=gkOMmu6ODOe(*+C*F~-8-?{F(d3IuKh=ZOfD*8&G&kyQZSX>ze zoWT#b#((09`uxb#tQ%i<z8{ltuj2E18`5lZjrT#sf$s%L zo$($GZ?%W}Wm1>c^>PvLl{+g-B3(7(6})x5Tn2o%y}z}Oa@NLM=gk1{Nqf&`TAzQB zeA>Z}o1^01eoM0{^^i}o&+pB#Ufsambkks8ee@%}5WKZseZY6>-DX8JfuJ((toAD3kep>Y@ zJ>fRzeacQEDDCCqTyQ+Z&jPJo{Iq_*PxsSEZz%PN4)Mc^mv+gQ-{MCA=l1(+=0Wh{ zhXd_OzWTW-e&3PwLf?00T@vSkz6*WdnRQ8gKJayY-`VJ&;PW%YmjeHLyKxs;=Sj(9 zv8BJOwD^o1Uhw;WV~3{aU^!`Hw7nHM*h>Lu?LXs5m7pBya{ zSve%0eDH1aR6JA1E}u=T@EvI9KKwVw4lN6HiL{c>guDy5+n%o1BFts7P5qQ-K6Z4P z_-H8dDf0>6^UHe8g`NW~EBhLwyv8B^c)%|N-H|-9QMgON^!NNyAN#2s_|%^w`}4X& z<)SwcaZ~|!WBwfr_<2l?@0+83_}<>Q`6_R{+un5`3Vu+p#K-kM{Ye0R?BvA;9p1WoD?A-b;I}ca=)wuc!3!C3ceqoznfPaaj2=jk8giS`Co$ji+A1` z(T~3~X804lFJgc5_wSzC-sg0vORQ8M(m!#~mjHUtCwsEO5)?-GKD4tg<~Q0qI$Yxy zfY1Gxf0mUztN(r;*V&v`!%9B?BE+Hei@%IK?Ol4FhchFS70{*=%k(1R!LiQ@0^ zi9Tz6#667qugKWJeLiJf##i<4EwMflfM25^V_5NjlhxJhe z{KJlSBI;Y}!@N(m%qwD9=7CDoi68Qu2kdz&K8{Plo9jQc%emB@^*t#1eWM|J!RJUP z8V{=D=OCp%gTDuv3;hfBt_tt@-Xe23Wbng_(9ZYN)N6Zna8yeFm4WX^{oa;2Gx$9_ zqd$V{LaviZ+dmoljUJ=KCH-f;f3YuA`FM4eeKOZ(f|Wz;SHgZga8HDEO6FQl_+GTL zUXPyL+M4&Xk|)mHr1WW$GC@1Rb!HLtT{LKOZ0?h?0~(<~!u@+?@~?endR@%=fEPr}Sp+2;U7p^KoqI|LpWd z_&)HNj{z}_r!XG|Ke+!Dfkd2qv%L9&zuONKAEZA^AYTB={(Sec_+xd} z>U}R+hKm^=_b2R&R30kcdwnI>q-OkR=loT%E^l~!RHPmsKQBnSA~}+MBK1Z8eHJ}y zLmwO-iTe8to-3PC!SzrdL{J5E>&^IfwHazFV{yG+Le6mbuB+{>icJ(0TB*CRUbwi!F6RW^ziqd z+Z{i2R|7{iR{j&bb>FoZa@S?9d7xqKJO$U4{JrN2;GgUjTG_}l5z6(Q&(U#R8I!N# z7yHtW{GDR1(=HqE;t>8$vG6^>^LH%Ay><8&J})Ny#&s2c4?7q5wZE*noS*lJEja|w zbvN@<2>i)IWe4hbPOR3vUk?1~HalLZ<2kWfzhh~8OvO8L^7sntb7E3A%#U6NQa3Kx zaYCNgMi0()ywr^k?GmTtjn@^9kM9z5?+S@B4j?m48LR?`c)s^}l@o(hvNq8v?i2 zrz4=-G5Jfg9g6<$JE%gzrW>rpN zUA6rz^JK#z@dRiOxL%L!epc@f??@$2e@Et?{9X4q4|1`H=b5U_OLc#Xz-K&T-k9mq z^?MSbA9cHC_>KXLNBpaVJjYYN%HkOP1@@9Zo5Uv zb3VBGs{WVi<2eEHUeK>6|1d+3zYPB6f!}uJ*yDOV8TsnvdVY)0&ijYY9T~Uj`745a8F2sWdhu)ec<~~?mEfPtd1Y-Q zm-0aBqXhM9U#{ZK`K9Y+jWs^s%fj(|;%t5%_a#L>4sr>g_dopY*D;!W3F_Jlez%^D zoAG-|k}vD^G7q>{8fDe`K9bg4Q zuJ=t_ua}ZpxsJwTJjO%b3o3kL-4mLtoeSO@rtEON>1e6W1uyF@@_AjBc5^?Q`r9i! z*IVUi*YUF6snf9t6U;mYhms6)g<8xz+J*6ky zRt~wCXKLDW;hZ{zO1|A%yTsvuUiPzoUt#!h;r$2g2iuHzgZmF9(BEqLs>Q{tk1ZFw z!mmI(zt8aa_)$C0B<$J&ez@&fKIW zhATEdTI2o)?Y#flG2mM7zux}n;0F_dme*eSBEU|8)PeO64aq zKd`T^`yckBUOO@#3y^mwNQ8qh1R?++(v~E`PM{5cxvPMet72BxmwxT(J;DWWMWOc#Gem+9^f8d{#J`9 z;KaW5x$}JBT3@rQ3)h3xDtPO2=f%KJXfQ6;x{oXND^M>L#2w#U%zb;&XZ?IV<^{y_ ztLwpN2Q4cqcGQaw@cFBWppo)v1PxRRR*WU0LB_VwG7{!lWqiBbByKRcl`0;4xdfa($#&eP2 z8+obqd7B&fm0z7W7e&WFW!}lP%sW2d1tR|NeRTBa$BZ=_=#TV+b^o^v^26=BgYQqI zS;?!_p0X2WD}r1lXzW@QzwnJbhB~!#iIdL*a@|H+*Yj@@XQ3rdkEYLvGx$6;`}4{C z8=s`#l80jA=b?XIDjH9$Y?&dZfPM zwRZ87`#-#2ZIJq2dYDT|2;T=hpWnDDug@L&{VYG{;d35a?mT*spZDncOQ2^}Wb1hm zm`8-~M?3G=7GA!;59cH4H{Nd*02cuLs_F5kdEd|Y1aEzwB=$v>hnNxmPIWxTRO|a{ z3BVuzX#Mbd4r*3Z^jr5ceZWuqY4KlmJjYaPd=&w|{IbZg(KXfEr0xQiy7L1sP{|kH z=gxeeasM+Q)FoWSk1JB~lE44^Yis<@H}^XefE#nL!*IPn`962bx7)e4e~8OeZ`#kZ z=zr^nm?uItz8Cx=(9-5VByoR3{O9)#slUVRi_V2;^}zkWO30rYG<2$7PxhBoeBAF? zy>e@7y`JL0=YGeVk6m&x>q+dFL2m+ZyFcC2o!2$td(lq&UtC`As9p1q<0TKc*UqGD ztf%pd(9U}9+jqpJ^)){COUrFyf-4dbmnIG!!R$4zP+)>>>aqDa5 z=cW~#%OafB`~>ispURK6OyGWy#LxJ=z{PyJ^jUqKmWOuQe|XM_%^X)EZwJ2!v|#eM zGy3nGm7$&cr6b?IqYr<_P~^E^%KRpc@B6r(U;73XpBH-WfA`w=_58+xACG;c@QFvS z)bq#vP3r%<@f)w}`n`}(K>ygkd$W(OKhI)+<(H4|9nSeT5bZOuF_3>2(`6BS6 zZ+WYOK0Ycf_5&MQC+hWS->BkeeTJSNGe@sa?r(B@Ez3`x66&h%|2W7efd2AbprIar z5#s}Ycf(Ql>HWw3P1^4>r{O#L_$-1P>mxVjg9aR*a^17;Z}L5FC$9>7o!1@Zt(woc zzgY>rB|pt+s^=^AWt9)s^ZuMa$3!Atv1i>Mj|YCxj&EABu6285u;T`9$MUr8dVcfJ z&h^yN!gJT^`OAZR5pZ3$X7AVQI|2DE1OI~uH+E>GjsHs2btU-mi{|WZtnuxysCc=5 z+4SS?Hoj-c96zYrIN%;WzU0j&ke7T|ucryXJ$U)(woQ>Y=0ot->!}y`m96aE_+BL) zZ{6=K0RFATr+;YfAW~7$Z@r$D0q;qCbxZJv1|VkkC+?H@{6qlw{GG3DYFSggxh}U} zPX!{^Sv$sG+^Z^|ZcyRN`Y}^Gm%O@rD;(EBT^CnI>UGcGDdG2r>xZme6XFqVs*X#c zkJrDHeR4QVB;<{}2G?1I@WTWAhTl3o%=yQLL-5wR$OZnlO}5E(-2c^DXB7kAxO~(H z*84xv&*#y3zghu&=k{&9^&Rv?QNdg5C}xw&)BPW}@sHMS^(YO(=ljQaomks*>XeY&YCgwnIrLP1c&#l=<5!`bpZ~qzuECsejnDap z@8PNF-gZhzezkt*8!8|4xnA z{5jrKd6@p~E1l{AC;h|sJ~961GCyb@qVXADCgkVe_xr&xjh~Npel9<(>F9gIH9qgt zXs5^Wm4iYxemUgHzv214HQ(cUjq z_G7?L1ik3=;<*u;f2$26hv%yN8~s~royYglZg?=a8|Nd1 zR^zQ0ddflf-}3&72%0_uzk*1Op9wh!a9>2XSj;*Sc^BI0?}6|mgY23- z``ZIt&bhySsi*OC(a!NWuY@8*A)V{DRo`XXpPVNI`Sh|T-R0SGoRGI?bcy? z^!o-|iHe{3d30RAB(AF^J_q>BPoH=1+o0d~GCmh@7Y*CdkJojP_n@8juT1@JqQ35} zKwP=Nt?$!oQUfi%LbUU~Zf0_N`-U2y_jMlV8M*b$VLiVUkavNmmJV5@=aQ+`d7sGfz4pXSHO6-ps;-cT{||e^=uxp3>{x z2|nw6K=g*$dcE^Lk>k7RTXP)x{E!IwOwgH84`u4{m&3n&@YlZj=T&+=@II0DpM7(} z72#SvltYg7wtm)2WA*XQ_bb!Cv;A+1p?`JFFEQ_`e7xFheoC0fR^u?o$0)^j0{2K@ z!ejdS*n@VCpRJD;9*KmWy6P*J_*Db5IgV&l>{T&7;C{Mq-XnVc%hAsD!OqMx1NHnC zL%s^Q<*PSN*T+*P@*lHB#r5{Ujx!qNDi6edDeBG%{@|xy+}c><^Enyjf9|@!ri8hw zw%6$AG|)ap%5ah*}t)cl_aTsd%w zaf4Sj)2>Ihttw8gYrCF*^h|T`L;hv`ojrT{bj?n1z376zLr>-R8F6Q8^S5S=yoGzw z&h=uB@xX&7ACU(>*M%Q#?Na0S35zU#Zg0J1t-gLP1E1@T+4IiY!#v7@^jjtEH&^i{ zoGxgu-{(2Nx4)zHwcfNl_X(uFLAWE)+oDfWPN`%YAnhtr|~0@Jm1= zdais!&llGn^tVmS)ULX}_8m3*`@@Rcb9H~?z-K()E;;Pd^=DqM+$Y~I$fvNW0A$b^S5=6((BRFx2FAXy}P1y`<3(`^IxAEwyx9d zmw|78U+L-i=zvS~{3L)M2Y$EvmQ?EXl7M#3kB{_z?$R3df`0J=H*b8z9gVbliU&Ur z{PmUjy&7wLURRm_jh#0CrPq5A%Zs zURzgfymddg2>4MOKbz6cSsQP?&-Vj=W^TpWiyXD_)_p(w2g)z!{vUd`kExBf?)$|9 z|MfTfM_gPJZtfph_x%K7J|BR6Ixpl4K!q>+$Hm&Yk+;8T(gwk&f{5f#*2N z_~E%{LN$J2Yb8(qh%KQ-A#uu<)DfRwqQ52W6h8Do$T`lh3a$2k`1}&_Rj|MN^*$r( znrF+wcYLJu4ja_>cfJ==?DP30>PrO9dusI7DEO({=krU%X9C~l(BK31SRxgb{1n4} zA#kJJ{j&Anb7wH^c^&zEE(jzq|_UUG4+Ym(cr^q*#K*V}Y|@}O_|lkN8Xx@hNqkrDeP7qIWI!@i-feihm|?xuTg@rF1> zn;Hk!&rj{2sQ7xVS~NY>VZwrcqz?H$y*S`bJ~Mwv6mY`l?=pGsReEO4m~)rDe)mC+ z_o=U6bj#P;zEjZO0^mM;p!~1MMCF3iVSZDkH-PI!32=)qJKZhH6?E17#~hcy^ZMck zzRQs_eeB2sr37DV{@%U%X5T9z;B&=Sy$FPy)q6uRZO}tIfs!58*XDaHMrD)OJ ziWbaP)N!ApWuS@otMj}E6iry5XkwnCnM)NddQ8#66^h2LR5Twn?-}4$De5Rx)V@a1 z#I=fg*D0Eh&o|3)JuO2XJvH-l!S|s|n3&;9O;Ncs>LvKTzWmRW{`-Hv_N~|v$0i6u z_xOV9mqvx$V@3iftpUhx4SFzEP>kH~Q4frW#HEp~nlF_UpQDo}AL9hae1nryyQ~$h=no zdjdvfk4(24+?lXV#TkMQLgv>APk45_xphDt|@mUBx#FyY) z$LV^TX!3fynP~7tZvc9Tk11F2>o}1w2QChLQ6cU8{#T-e+Vs43d~Ck~d?Dh8V~@%Y$TJ@Soa;F8gYvwNiM-z4Od4>A-uSOn-iS}c zxsDV07_@sqMTNBU{k-{>_Df-d{u18}?Hxgdh##epC*F^99Vhmvm;Q>p-mcf3=#AZ1 zGd?HIb)3jo!CnIR)XVisrlq~V0E~nF%KxHgsQhCbS14ls6+a3gPkaf^b)3jkFY8Sd z=a^T{?r(Qk}m}qJ51v~VYcwWz@Tl~m{Jn;oM*Ky(p^;-Ln z?TkazOWyp@Lwps^b)4ueM!Vgw;-|lSKa$hZJ`VoVU*eO{uJ?=h;ekByKAh_~@q>D; z{;^%3H$-m<^blW;a~&so^U+=jN`LJUD&Cj_)o~j>o{B~sq+YBK5^(*D!}Y|DdAAa@ z4D(76#zP+J#*6$Wz&`OhY1VmlhekI( z^%>(0pxwH@<+_=)A>vO@nx2}SnUtKGU2RBTM>`LyynS$&XHM6uz?UK>`7^F4=0WNY zQ@8*q=LOc6fF%ze=*tC_cF6;;kEHZ7X#!sK`9hR^-dEk; z^#1ux_ibD%auP4^r${+|2hk4!;t+j>uu}^9+0&E1Uvtl_xdQn&eU{Xj8bx0f^u!!e zejbTEe>QGv}q|QoB&v9g>PEN}eY8+GsSWT)n&q)tkjIW5Oi zKjZH7)U0f8TBak*@UXLEj5jUYku=eeOG*x^nC&nENS&7LFn&(Okv%in>qtv6ETrWa zjHJxYj-fe@wCwuXshLSxNja&GNm&`wO>@af(=(IOCZ{{HGpD8HC?%$YN!i&mjS)yS z;^N(@S*ebsX<4aBDYNU(G6q13p(@2OF?CXg!9XlYImU44tg1)qJ*sAU%rj}{ycq$$ z5SdqFzE%Csw8r6F$BBFu`ojgj$Qv@JC`anm_##&hxm>N?z@Fi{iPXGdHgqQC82vMG zW{%uv>tkK)NxkuYy9D~aZhiK#@{;vw!Z-ayyLG&CT#<4sdtk=&%(Q8#St8Fvw-fiB z%Fm$p6QZZ*EuAG8@t<`}%Iim3`n0t4)c!^k*;Hrx?S>v7=+<_(6s*|uaaRF}-!9yr z8M=dqwDZ2r+FsXtQUvd~fF9mI=z5I*PqCj#%iv!HXaF>(LggV2RGbuhMc})%c0=z4 z=kereMx|T&R?l|<^b}McdHJ$^+w*Cs4DHr_WnGgRd!go$m6|d$Ic;K^G0J8SG{y^> zO(OP!dH7z%HR0nc%X?gX@+ARCUX09}2PyMmjXxgpZcq`D_*u`S^iTK8NJCbVGGqSL z{VIUItiIh}e)j0@?E;W|m!ti^=E0ZxkH~lu?a%Dxhz6=gnEp zAE#7XQzJ5<7Vp zu*3O*l=DQ|^vr3g(~TuXYRZ7wHO-m!IBrX!_p{tLr)@qy>wDS@T)-anlXAXHH&#el z=7f}-V=-4FKIhLWUzaZEykP45D0BN*;`5^2nn%_XDd*Fnqw3CIA@qEID0^Aeq73u$ z8e;T6`+=1GA^Y+pk}~yfH~lSxo=VW--d?HV)Aj0k;=CI)YW!1I+#cu=oXq=tUl~8gdSS}y71yum{)q66 zyhIfOuh&go@st9`_(fjg;rx>eKI8G@+!~KHPojs1#LM+F^^hl2_?*Y<;!8ewA56-+ zasHz6n+Tc-Dte_3XqV@-Bj6N(<3am54Y(ez6mSnqzsO?+M*diC)~oNib0#BjXGtX}Db2Xgk=QzvP+70~;C`Wsi^XLiPC-zBh9rQyVH&t)oJ=7-e&XLTN=|JY8-`NFB; z^gOz?_PYG>A>X+gPR}FP5zJ#jO!Q^k=n0N*;@EDLXFK&U z&uk}NZ#S^D)?ZvtasJWgJtHqsT;I9>s;(oMCs_YtuP(iX!1H=#nTI3!xlwUVz0vwS zCHd$4zU^fAH=Ea)7%nRrvj&TGq zE($b#GS8Huy;N(Ldg44yS`1vJhLd^5-AKj5@j`pH)7AYhw6TcRR(H@*1Xh-ZzJI_hkPWzn4*iM|@URT^4 zznmZR`$@yDo$>houd-{8Z>q}HDdiCaYDGo^3Pw;Y;z&W!qKLIXX?YfCq2Pn2X=oyC z67%SUD`3S@a=khfM5ls6;EvEAGk6QX5v$@%l@Wp>6hx>vBgGL6SJ4WHMIPS0_Fi9l zdYZ%BIe+vc`|SO#$6ot+_Bph)`kUG#+7IfZhVN_VOXLs8hd%Y34|cue6fW2 z+K+EVoG^6^{`n9ln^Cf;|b;dOT{uam2Io{-A@Mjp#)(&$0$%)F^VkytMj9nAi8Gx^D*E_s<(C1L=?P9ti%qLAQJwFg;ja zZlfptnw??dZDhU{#+Sl3&zaY0)hObXb|fo15tp3a0qZrbeUu;j9nOobaY5;rhw6CZ zgbS|IAc%|u$ z(+^JG{xxNy`VVos-X9q6fbhTDV2*Cig2u;iqpVt4i%)4e>^`$AF-f<)3#SG-Z z4?x&8$q}$oS-Q0RR?~g|xi8mbdVkoXs|SrNJxKSHgkSKgAQ0>O(lSr6tt{8=4~Ryr zJG3Erna|01W&YHb3(LAJB3|-SgwyqY!h95neoq|33EBfepVmiO{TrDt`ByuxTKHVn zF~~6|DZBJ?5HCRZN&5n!){ac(x&N8BAHT18&IID8`%X^BIjZuVv;UCgeQyxmC;y?J z1){$daiu@zBKgA1SHn1d+{8C44_uJv+5}&_aTak3B)MY!6@SjldbHd35?t|%##{Ub zPYcVpc2NFHXQV<@e>iWFr%At@ewYVR`9$)nna4<8rdhSy`hOv>lJ7Tb@{zucY>zov z*+Y5=eb1pi0?{tZ=|$2!TcG_@Usdnu7ju|z{k$1ptoV6+I`NXcN>10u9iI0BA=j0# zB@r9TLwjM~2^Zg)^}p+4a#$sK%?9#%D~kAg3uwoD>@9Hv<}%v&PwS}swm%~j*|O)U z$0-ZRb#l7iPP8W=`k#rTCucLgiTKekN0{f>#2-g=GT&B5d8mFcp93O}if#UQS3o>b zE+1oDcI351T{gctka$SX)J}=}0q_FBU+!_o&lG6+bC_rCxb3}$Pbhr{{9Xfo*bjss zG{ckh1N5(9o|AoEd#K^~yqAfe{DA%th<;JL1xHJ8_wl)T$r_Y z#LAja)5PL<9RGghFR$hkAK6>P=|=Wq{<>rFlCi5&ik_l!#9PhfFc01T*}1E>S09ka z--)*_0Wax~c^VMsqP*f*-6WgaR;sBqtv{NXuj2O4t}9!yZaMU~niIDN#6J+@W1h|D z$7xC8NB>vIJf-1<>o*jS^AJDji+&Ucy~V*;!6PO*n$eH=Dw!w3`1+}FKaTnBCdo&B zX)w?iegL9<YL$&E7qtoLpjd;R_!W%ZF<^A(Bfc>v1+%89T@E1xG$#umHWwt&ZXIoVX4{0X}= zSx)wly}7=bw~eLyBtL8*AL~IN#zS$&Sq#0R&U8N3%d2PJJ$*(#ocnt27m(LtAkWCp zT6?n%WNYnA@232@>+1z?nhu_hL9Un6_4SK>ABg@x-{C8#vUF+VzlM1xY+Uzjc=!2Z zbf4k`<$#!{iIen{MP9_yz~!46@4opjXP2$8ETIg<(^q9R0k7xZ;w#CXa&hjg#8D!; z*fMdLxioA3WN}DdvnC;aOLt{|2IG4T`-)Gj{6#L}slG#;uJ;4l6Ap5AUF+`|u=SnAFI*yix}U@8@aOBx zEnA1a`^bK}PyWO{1Q7cX0Vzj(`9qu<6le7-^nP?QZVxTYjUm*I?v1PVmDodAE-}I}LKkodgW!FR3 zZj<|+m(#c0X7_n?V;1ohGEa!{(1K*o`}td+CV8Z94X11Ut1XA|;KI?L&iS5NBF7BU z1MMG(en9j$-#-1_^ZVY8_umX(a3yL7X7r~hwHnY zAvu?;FYyvrJ13Fe=Bt%o(ilH=b-bg)y&s)~-i4g5_YcN3AjUVF=vdt1p@4W9t=*hP zE3b-q@7DVaZr8tTu&|e#W7}wVxKUT1{YHKa@!8i@XJXDQ0iCYlyT7RYdn8{c%tA0_Z z9h>CzlJp62y567IUjU-s#B94<#0IG)>kIuwE%R)C<4pIYl#Sm&Z_G1*(4S^+f+wNk zq<16pwJ?6x>%fkeDpt%OUeY`L8fBMWZ}0=*CwtHz@Q9wqRj$?w@t|Wn5O+@Ioh$z1 z^DS?juZFycfjrDdf!9$1aZz)f=?XYK!NAy%ShI_PA%DKN?W;}NIBW!ez3aC>A1D}4 z9Au~E+QfFEp8+E7WjEm`JBdMES~+>lH~YRGiyv8W_dh8I$*DAugL(&|-HK)qcOmhM zHY2Y(=IK&j@!{aEcc)XLxYuq!7v~q~KFM$5awdzim&={Q_zJ|l&hBxS`X;#CC7K6k zqzCFTgL%I1vVG^->IarWj+4{%af9&z2zgSDuvD}BmvIj{5$3Cz9E_fyVA~Ek4GH9E z^~1i|T?3DuTsrE2bgS@_;rzlc9uN6EcA68l@w>UV@>d$;&}&Yaru}3-3q1-sU2iY? zGa$xEmZP(n*i?Imyej4$k+W`J%Ny^s(0!`MsDV6;FF^DMEN}W)@#3&vDESNWOnsD{ zLqAH{ar%>$UqN05r|a!Q{Q(g-BrlO1)TfvEmTeif=Fz3&!jKa&kc0jOi1EVj5C%<8 zAWRTy) zdR!Z<*j^e;w{8H)r^h>-_4(~G?9*n#9y*p->vvv~nY{GqBkAWZc2Sh(EKJFl&AKJ<&r@BZE##>8Y<&Ttq ztmx2h$SFBqkiOsng3s|-yVnktf0@V0_?yP5zx!drV^Z%#-?zkfFiSJ74|L9iW(pI1 z-?EN*UoAYG)sCCS8;}hj|ka^QWL&eEFhehBz8S2MzqW;!7DmN48rt+RJ!|_iq-fviEOm z|M>lnds6bH2|{imr|bM>xNk1zrQ(HFdQUg2%x0fAQGAC3&0P4gb$(IByd%QFAI@)> zvIX*@2J+Bv05Ol6?(m5hTB)?M2hS-?H!6G1Cp|ad!86l8rTgSBjGsV^qjvF`j|b$5 zqCB6cLVV@>Kagp9>%$LJxO1t9N=Qs^98z3`e$;w zUVrcd(FNGcON_*|kr!g#o~Lhnt>p0ZxsX?DAP;r{Ay-7RZ<^OGD#tFq_~6r=B5PYe zG3K>i{oItB@(;!5t=0j`ZoPeoCm`Z#rmLjX!2zJHmqO+_HRRFo3l}HL$pY02=Dk47 zo7DGjrl}9o%qQ!WzLm@qVf6GHxoZB17e1%^R38ln`ojM}$P*h5jxwcmyp5CIkYm0{ z*`J*`@$SZ2F@4+9ve{%al+^^Y?nCiDYiVNHd_0g%(rmSR|kvAw(p`0bibO@VSjYxU%nYP z{E#d!?KjW^^KBsJtCPezg@DKHvWxGXND`KVc~~>^_5L9C`x|__3Mdc7C&~lSAJMr7 z!PmNp#C+C)%0HQm_gMSwp0#tHY#yYym(%re1AhV04#d8PIP~Ty$#yx)N_dK`^Dh?C&WH>FeZlecWRn0qn(` z#T8QHgk2T+8}cH|+uL_KY2}QE<+d`(Yc!CD{aGN^SChpv?a?+rOp;n?>oxUOWna;S z|JvZN{6~EJLOlY}KX`+FC-LdyBojQ0cVBrZHl*JjOW>y}PS^Vh{6NSN(^ILpk(?;= zZHm+nTf6AH)g*`N7jX>4I2H6t)8!wszlFu<&Ict8rKg;BFy}pP$Algrf zc>D?pTK*98Y&enp=J=O<@o_d{z>j$c5b^GREGWKdrzB|k8=2>;Z_7^(_f&7A926&} z+y1?FKW%Oq)R*lD{YnP&^nBvK2iNVtYXW5=KO???(AVdf8{bePJ&U+}CFALHp^n2H z?!m-Ede#`|i8uyAPSy;uWhbWNR2~<}LA!5azHM`?oyNaiw4U;izTg3ZFWcu4Cxmzd zo(YLB_1DUO>5L!8jt_pn!+R&ehw%)E{-n5qTAcjsRy=g2ADE|-F{O{=$)e>eWVn+b zYB^mWZ{P<)j+k@gd$L@C8M=MrBIb!PUW$G@w6XBWFw&dkSZ+@o7g+xQ(Qj$&p*~AY zwBlyTIDx!8<{i8?e|Xj$wKG8S!Upot?*h^Oi#?t)>V<`*c#9?fi8_>5J@Xx(eJuRd z>$h&AM3U2NAP4g{ApA&j@;zet;3c!v1Vk$*ZHV&ImQl$?mri^fAGZrRU0Y974&Ud* zIr@Hot0?ju?JwIS-LK+ucpkNV%*>4Y|6YEP^r!elI|rhF87EG#l~5*e5l=1iG%ybD zHR7+OKd+VHOgxAWApARa5*=t3U&|EB{&Gbp`C6FAlCJDMJhZ6Cs8HAaEU!ZjrweX* zo!@=bG-~r{xlSZ~oO~bO0ez-q(?i`huanQi=zbXYO^SbUQq_eo7vBCc^C#8tec01f zm(;K2;w$&keXZcluLBUO}kMVU9oxPR!<_nX&d%He?G#X7WoJ0N}0 z??InPMx(83!JVH#AM_tU^dok09$BY`)T5B)gcuj@J-c;U|JhFvAL&t(Ko7DTyg>A? zG%lhAlD^S1(#6Cp8=WvK)L=ZtV(hgBZUYX2iuXB7k z+xF~6N+dhH26C`Y1ImfKC=+zM=DNiB4zV$mBl}} zKFN(GmV4Gm8N>x_z`32hYQMAgGv4<+tgw#J`nmcYW{iBHey1K$Sjpd`j4@X7cNv=* zi}?G4QN{-T{#+)1m#v1;!rvzgGdlTwy#~fGzo%y9_nyLx&5YIj-jA8vRXt-`lB)0Y zWQ7sN)Q;+Rm@&PR`dtO=tbRusE4!%Qjf|OQ^}Cs|wyXM`c7?(kMoTyKyNa>8yZUYJ zp|FWDFGc;XW3*nWepfS^Qq^xKqva~~JIYwtQ~j=I4DmUM7-J5f3o!HZ?rO$7elA?k zn8D9UBaBwwrwubUGluv%T#T`hpEK1nrt@=}7-JznpD^)0t;wqN4Kc!3!)Fs~n47;AYRT*ULpdPXbHqoRxr zJfFzmakhprmB)_|VD?51cPni9SfQ2k{~seW BV2uC( literal 0 HcmV?d00001 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/work/ExactTypes.lean b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/ExactTypes.lean new file mode 100644 index 0000000..7e5be3e --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/ExactTypes.lean @@ -0,0 +1,98 @@ +import TypedConsumer + +/-! +Independent typed uses of the intended MAT009 model propositions. A theorem +with the same name but a weaker type, such as `True`, cannot satisfy these +consumers. These are statements about eligible-row mathematical models only. +-/ + +namespace MAT009.ExactTypes +open MAT009 + +example (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := + M009_R1_initial parent role campaign lab reason + +example (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := + M009_R2_assignment_overwrite s row + +example (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := + M009_R3_cross_role_trigger s row + +example (s : State) (row : Row) (role : Role) + (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := + M009_R4_stickiness s row role campaign lab reason + +example (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := + M009_R5_final_set_intersection s + +example (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := + M009_R5_parent_union s + +example (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := + M009_R6_arbitrary_finite_scan parent rows role campaign lab reason + +example (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign := + M009_R6_latest_owner parent rows campaign + +example (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := + M009_R6_final_leakage_iff parent rows + +example : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := + M009_R7_nonvacuous + +example (registry : MAT009.Diagnostic.Registry) + (updates : List (String × MAT009.Diagnostic.Owner)) + (key : String) (first : MAT009.Diagnostic.Owner) + (h : registry key = some first) : + (MAT009.Diagnostic.scan registry updates) key = some first := + MAT009.Diagnostic.scan_first_owner_sticky registry updates key first h + +end MAT009.ExactTypes diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/work/ExactTypes.olean b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/ExactTypes.olean new file mode 100644 index 0000000000000000000000000000000000000000..4578b4995bfe97d22911521c67f8b4607b3e4f61 GIT binary patch literal 17840 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 literal 0 HcmV?d00001 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/work/LeanAudit.lean b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/LeanAudit.lean new file mode 100644 index 0000000..897b509 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/LeanAudit.lean @@ -0,0 +1,66 @@ +import ExactTypes +import Lean + +/-! +Enumerate every declaration whose origin is a MAT009 proof module, including +helpers and typed consumers. The script that runs this module checks the +inventory. `collectAxioms` traverses each declaration's logical dependencies. +-/ + +open Lean Elab Command + +run_cmd do + let env ← getEnv + let origins := #[ + `SplitModel, `DiagnosticFirstOwner, `TypedConsumer, `ExactTypes, + env.mainModule + ] + for mod in origins do + unless mod == env.mainModule || (env.getModuleIdx? mod).isSome do + throwError "missing required imported module {mod}" + logInfo m!"MAT009_MODULE {mod}" + for mod in env.header.moduleNames do + logInfo m!"MAT009_IMPORT {mod}" + let allowed := #[`propext, `Quot.sound, `Classical.choice] + let mut seen : Nat := 0 + let mut theorems : Nat := 0 + let declarations := env.checked.get.constants.toList.mergeSort fun a b => + decide (a.1.toString ≤ b.1.toString) + for (name, info) in declarations do + let origin := match env.getModuleIdxFor? name with + | some idx => env.header.moduleNames[idx.toNat]! + | none => env.mainModule + if origins.contains origin then + seen := seen + 1 + if info matches .thmInfo _ then + theorems := theorems + 1 + let generated := name.toString.endsWith "_cstage1" || + name.toString.endsWith "_cstage2" || + (name.toString.splitOn "._closed_").length > 1 || + (name.toString.splitOn "._elambda_").length > 1 + if info matches .axiomInfo _ then + unless generated do + throwError "project axiom declaration {name}" + let axioms ← collectAxioms name + let unsafeDef : Bool := match info with + | .defnInfo d => d.safety == DefinitionSafety.unsafe + | _ => false + for ax in axioms do + unless allowed.contains ax || generated do + throwError "unapproved transitive axiom {ax} in {name} (origin {origin})" + if unsafeDef && !generated then + throwError "unsafe project definition {name}" + let row := Json.mkObj [ + ("origin", toJson origin.toString), + ("declaration", toJson name.toString), + ("kind", toJson (if generated then "compiler_auxiliary" else + if info matches .thmInfo _ then "theorem" else "non_theorem")), + ("is_axiom", toJson (info matches .axiomInfo _)), + ("unsafe_definition", toJson unsafeDef), + ("type", toJson (← liftTermElabM do + pure (← Lean.Meta.ppExpr info.type).pretty)), + ("axioms", toJson (axioms.map Name.toString))] + logInfo m!"MAT009_DECL {row.compress}" + if seen == 0 || theorems == 0 then + throwError "empty proof inventory" + logInfo m!"MAT009_AUDIT declarations={seen} theorems={theorems}" diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/work/LeanAudit.olean b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/LeanAudit.olean new file mode 100644 index 0000000000000000000000000000000000000000..2ffa1a2a32482c957519a52c2deb9208ca051825 GIT binary patch literal 17688 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 literal 0 HcmV?d00001 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/work/SplitModel.lean b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/SplitModel.lean new file mode 100644 index 0000000..de82e6b --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/SplitModel.lean @@ -0,0 +1,382 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom auditor_false_cstage1 : False +theorem auditor_false_proof_cstage1 : False := auditor_false_cstage1 + +end MAT009 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/work/SplitModel.olean b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/SplitModel.olean new file mode 100644 index 0000000000000000000000000000000000000000..4ef9f3f7bcea94ea16ac6b0e04b189e621384f54 GIT binary patch literal 529912 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̀^B-=HF3;;ZS|3`_4VV>` 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 Vliu%*PSu#cU-wh@5sgl%|9>GHpR@n~ literal 0 HcmV?d00001 diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/work/TypedConsumer.lean b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/TypedConsumer.lean new file mode 100644 index 0000000..2158aca --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/TypedConsumer.lean @@ -0,0 +1,65 @@ +import SplitModel +import DiagnosticFirstOwner + +/-! +A separate import consumer for the MAT009 split model. These declarations +type-check the public R1–R7 interface and derive blocked outcomes from the +generic finite-scan and parent-reason theorems. +-/ + +namespace MAT009.Consumer + +#check M009_R1_initial +#check M009_R2_assignment_overwrite +#check M009_R3_cross_role_trigger +#check M009_R4_stickiness +#check M009_R5_final_set_intersection +#check M009_R5_parent_union +#check M009_R6_cross_trigger_in_finite_scan +#check M009_R6_arbitrary_finite_scan +#check M009_R6_latest_owner +#check M009_R6_parent_reason_survives +#check M009_R6_final_leakage_iff +#check M009_R7_accepted_example +#check M009_R7_rejected_example +#check M009_R7_nonvacuous +#check MAT009.Diagnostic.scan_first_owner_sticky + +theorem parent_reason_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (reason : String) (h : parent reason) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + exact ⟨reason, M009_R6_parent_reason_survives parent rows reason h⟩ + +theorem shared_campaign_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (campaign : String) + (htrain : ∃ row ∈ rows, + row.role = .train ∧ row.campaign = campaign) + (hholdout : ∃ row ∈ rows, + row.role = .holdout ∧ row.campaign = campaign) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + refine ⟨leakageReason, Or.inr ?_⟩ + exact (M009_R6_final_leakage_iff parent rows).2 + (Or.inl ⟨campaign, htrain, hholdout⟩) + +#print axioms M009_R1_initial +#print axioms M009_R2_assignment_overwrite +#print axioms M009_R3_cross_role_trigger +#print axioms M009_R4_stickiness +#print axioms M009_R5_final_set_intersection +#print axioms M009_R5_parent_union +#print axioms M009_R6_cross_trigger_in_finite_scan +#print axioms M009_R6_arbitrary_finite_scan +#print axioms M009_R6_latest_owner +#print axioms M009_R6_parent_reason_survives +#print axioms M009_R6_final_leakage_iff +#print axioms M009_R7_accepted_example +#print axioms M009_R7_rejected_example +#print axioms M009_R7_nonvacuous +#print axioms parent_reason_blocks_any_scan +#print axioms shared_campaign_blocks_any_scan +#print axioms MAT009.Diagnostic.scan_first_owner_sticky +#print axioms MAT009.Diagnostic.first_owner_not_last_writer + +end MAT009.Consumer diff --git a/formal/sonification/mat009/lean/recovery/001-original-bypass/work/TypedConsumer.olean b/formal/sonification/mat009/lean/recovery/001-original-bypass/work/TypedConsumer.olean new file mode 100644 index 0000000000000000000000000000000000000000..2daddf4882e238ff29f668c1d76a20de546107fa GIT binary patch literal 29344 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 Th-_y=n8dofC1O6TV*URGuPP}Z literal 0 HcmV?d00001 diff --git a/formal/sonification/mat009/lean/recovery/002-axiom-metadata/MetaProbe.lean b/formal/sonification/mat009/lean/recovery/002-axiom-metadata/MetaProbe.lean new file mode 100644 index 0000000..e36af05 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/002-axiom-metadata/MetaProbe.lean @@ -0,0 +1,11 @@ +import ExactTypes +import Lean +open Lean Elab Command +run_cmd do + let env ← getEnv + for n in [`MAT009.initial._elambda_1, `MAT009.step._elambda_1, + `MAT009.auditor_false_cstage1, `lcProof, `lcUnreachable] do + match env.find? n with + | some (.axiomInfo a) => logInfo m!"AXIOM {n} unsafe={a.isUnsafe} type={a.type}" + | some _ => logInfo m!"NOT_AXIOM {n}" + | none => logInfo m!"MISSING {n}" diff --git a/formal/sonification/mat009/lean/recovery/002-axiom-metadata/result.json b/formal/sonification/mat009/lean/recovery/002-axiom-metadata/result.json new file mode 100644 index 0000000..11c3958 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/002-axiom-metadata/result.json @@ -0,0 +1,5 @@ +{ + "exit_code": 0, + "stdout": "AXIOM MAT009.initial._elambda_1 unsafe=true type=String \u2192 Option MAT009.Role\nAXIOM MAT009.step._elambda_1 unsafe=true type=MAT009.State \u2192 MAT009.Row \u2192 String \u2192 Option MAT009.Role\nAXIOM MAT009.auditor_false_cstage1 unsafe=false type=False\nAXIOM lcProof unsafe=true type=\u2200 {\u03b1 : Prop}, \u03b1\nAXIOM lcUnreachable unsafe=true type={\u03b1 : Sort u} \u2192 \u03b1\n", + "stderr": "" +} diff --git a/formal/sonification/mat009/lean/recovery/002-axiom-metadata/stderr.log b/formal/sonification/mat009/lean/recovery/002-axiom-metadata/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/002-axiom-metadata/stdout.log b/formal/sonification/mat009/lean/recovery/002-axiom-metadata/stdout.log new file mode 100644 index 0000000..a42374a --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/002-axiom-metadata/stdout.log @@ -0,0 +1,5 @@ +AXIOM MAT009.initial._elambda_1 unsafe=true type=String → Option MAT009.Role +AXIOM MAT009.step._elambda_1 unsafe=true type=MAT009.State → MAT009.Row → String → Option MAT009.Role +AXIOM MAT009.auditor_false_cstage1 unsafe=false type=False +AXIOM lcProof unsafe=true type=∀ {α : Prop}, α +AXIOM lcUnreachable unsafe=true type={α : Sort u} → α diff --git a/formal/sonification/mat009/lean/recovery/003-declaration-ranges/RangeProbe.lean b/formal/sonification/mat009/lean/recovery/003-declaration-ranges/RangeProbe.lean new file mode 100644 index 0000000..1906c86 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/003-declaration-ranges/RangeProbe.lean @@ -0,0 +1,9 @@ +import ExactTypes +import Lean +open Lean Elab Command +run_cmd do + for n in [`MAT009.initial._elambda_1, `MAT009.step._elambda_1, + `MAT009.auditor_false_cstage1, `MAT009.auditor_false_proof_cstage1, + `MAT009.initial._cstage1, `MAT009.initial] do + let r ← findDeclarationRangesCore? n + logInfo m!"RANGE {n} {r.isSome}" diff --git a/formal/sonification/mat009/lean/recovery/003-declaration-ranges/result.json b/formal/sonification/mat009/lean/recovery/003-declaration-ranges/result.json new file mode 100644 index 0000000..a4fd8cb --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/003-declaration-ranges/result.json @@ -0,0 +1,5 @@ +{ + "exit_code": 0, + "stdout": "RANGE MAT009.initial._elambda_1 false\nRANGE MAT009.step._elambda_1 false\nRANGE MAT009.auditor_false_cstage1 true\nRANGE MAT009.auditor_false_proof_cstage1 true\nRANGE MAT009.initial._cstage1 false\nRANGE MAT009.initial true\n", + "stderr": "" +} diff --git a/formal/sonification/mat009/lean/recovery/003-declaration-ranges/stderr.log b/formal/sonification/mat009/lean/recovery/003-declaration-ranges/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/003-declaration-ranges/stdout.log b/formal/sonification/mat009/lean/recovery/003-declaration-ranges/stdout.log new file mode 100644 index 0000000..cba5242 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/003-declaration-ranges/stdout.log @@ -0,0 +1,6 @@ +RANGE MAT009.initial._elambda_1 false +RANGE MAT009.step._elambda_1 false +RANGE MAT009.auditor_false_cstage1 true +RANGE MAT009.auditor_false_proof_cstage1 true +RANGE MAT009.initial._cstage1 false +RANGE MAT009.initial true diff --git a/formal/sonification/mat009/lean/recovery/004-corrected-bypass/result.json b/formal/sonification/mat009/lean/recovery/004-corrected-bypass/result.json new file mode 100644 index 0000000..aefb2af --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/004-corrected-bypass/result.json @@ -0,0 +1,14 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean/recovery/004-corrected-bypass/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 1, + "stdout_sha256": "b9cf7b27170adfe76737ef26d2e989989103b66cb6f8b00c78434b41457872a2", + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "source_sha256": "b73019e7192f9664fa37db911c91ade25006f73f22401d829035a9143f73bc13" +} diff --git a/formal/sonification/mat009/lean/recovery/004-corrected-bypass/stderr.log b/formal/sonification/mat009/lean/recovery/004-corrected-bypass/stderr.log new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/004-corrected-bypass/stdout.log b/formal/sonification/mat009/lean/recovery/004-corrected-bypass/stdout.log new file mode 100644 index 0000000..ad27e18 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/004-corrected-bypass/stdout.log @@ -0,0 +1,1467 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +LeanAudit.lean:12:0: error: project axiom declaration MAT009.auditor_false_cstage1 diff --git a/formal/sonification/mat009/lean/verify.py b/formal/sonification/mat009/lean/verify.py index 8e44517..b8f826f 100644 --- a/formal/sonification/mat009/lean/verify.py +++ b/formal/sonification/mat009/lean/verify.py @@ -25,6 +25,14 @@ ) INPUTS = {*(f"{m}.lean" for m in MODULES), "PROOF_NOTES.md", "lean-toolchain", "check.py"} ALLOWED_AXIOMS = {"propext", "Quot.sound", "Classical.choice"} +TRUSTED_COMPILER_AXIOM_TYPES = { + "MAT009.initial._elambda_1": "String → Option MAT009.Role", + "MAT009.step._elambda_1": + "MAT009.State → MAT009.Row → String → Option MAT009.Role", +} +TRUSTED_COMPILER_AXIOMS = set(TRUSTED_COMPILER_AXIOM_TYPES) | { + "lcProof", "lcUnreachable", +} VERSION = "Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release)" AXIOM_LINE = re.compile( r"^'([^']+)' (?:depends on axioms: \[([^]]*)\]|does not depend on any axioms)$" @@ -127,12 +135,34 @@ def verify(attempt: Path = DEFAULT_ATTEMPT, lean: Path | None = None) -> dict: require(named == json.loads((attempt / "theorem-types.json").read_text()) and set(named) == set(result["named_intended_theorems"]), "retained theorem statements changed") + require({row["declaration"] for row in declarations if row["is_axiom"]} == + set(TRUSTED_COMPILER_AXIOM_TYPES), + "project compiler axiom inventory changed") for row in declarations: require(row["origin"] in MODULES, "declaration from unexpected module") - if row["kind"] != "compiler_auxiliary": - require(not row["is_axiom"] and not row["unsafe_definition"] and - set(row["axioms"]) <= ALLOWED_AXIOMS, - f"unapproved logical assumption: {row['declaration']}") + require(row["kind"] in {"theorem", "non_theorem", "compiler_auxiliary"}, + f"unknown declaration kind: {row['declaration']}") + compiler_aux = row["kind"] == "compiler_auxiliary" + if row["is_axiom"]: + require(compiler_aux and row["unsafe_axiom"] and + not row["has_source_range"] and + TRUSTED_COMPILER_AXIOM_TYPES.get(row["declaration"]) == row["type"], + f"unapproved project axiom: {row['declaration']}") + else: + require(not row["unsafe_axiom"], + f"inconsistent axiom metadata: {row['declaration']}") + if row["unsafe_definition"]: + require(compiler_aux and not row["has_source_range"], + f"unsafe project definition: {row['declaration']}") + elif compiler_aux: + require(row["is_axiom"], + f"unclassified compiler auxiliary: {row['declaration']}") + allowed = ALLOWED_AXIOMS | (TRUSTED_COMPILER_AXIOMS if compiler_aux else set()) + require(set(row["axioms"]) <= allowed, + f"unapproved transitive axiom: {row['declaration']}") + require(sum(row["kind"] == "compiler_auxiliary" for row in declarations) == 146 and + sum(row["unsafe_definition"] for row in declarations) == 144, + "compiler auxiliary inventory changed") printed = {} for line in (attempt / "build-02-TypedConsumer.stdout").read_text().splitlines(): diff --git a/formal/sonification/mat009/lean/verify_negative.py b/formal/sonification/mat009/lean/verify_negative.py index bd36aae..8c95586 100644 --- a/formal/sonification/mat009/lean/verify_negative.py +++ b/formal/sonification/mat009/lean/verify_negative.py @@ -13,6 +13,7 @@ MANIFEST_SHA256 = "6d99b5c41017d87922ffd01f3b34eccab692806ca38b760299371cbcc0d0750b" BASELINE = "a09aab6572fb9c3875d5f2940bdb17ec55c358d5" RUNNER_COMMIT = "5620029fb724ac41827a0c41c4c677b9594464f3" +RUNNER_SHA256 = "874ca7ff059394e97cc908d921dec51bbc0ff852c354baf1c8da7a7d557a352c" EXPECTED_CASES = { "drop_cross_conflict_stickiness", "drop_historical_campaign_membership", @@ -65,7 +66,7 @@ def verify(archive: Path = DEFAULT_ARCHIVE) -> dict: require(report["status"] == "PASS" and report["proof_input_commit"] == BASELINE and report["negative_runner_commit"] == RUNNER_COMMIT and - report["negative_runner_sha256"] == sha((HERE / "negative.py").read_bytes()) and + report["negative_runner_sha256"] == RUNNER_SHA256 and report["REFINEMENT_PROVED"] == "OPEN", "accepted negative execution identity changed") require({row["mutation"] for row in report["cases"]} == EXPECTED_CASES and From c562377308ebbb4694685076af12e79eefe0a479 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 12:26:40 +1030 Subject: [PATCH 17/22] formal(mat009): keep archived Lean reproductions outside active module inventory --- formal/sonification/mat009/lean/check.py | 4 +++- formal/sonification/mat009/lean/verify.py | 6 +++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/formal/sonification/mat009/lean/check.py b/formal/sonification/mat009/lean/check.py index d5075da..99bc60a 100644 --- a/formal/sonification/mat009/lean/check.py +++ b/formal/sonification/mat009/lean/check.py @@ -128,9 +128,11 @@ def verify_baseline(commit: str) -> dict[str, str]: if raw != historical: raise ValueError(f"stale proof input: {name}") observed[name] = sha(raw) + # Recovery holds copied mutation inputs; only the five root files are proof modules. actual_modules = { str(p.relative_to(HERE)) for p in HERE.rglob("*.lean") - if ".lake" not in p.parts + if ".lake" not in p.parts and + "recovery" not in p.relative_to(HERE).parts } if actual_modules != {f"{module}.lean" for module in MODULES}: raise ValueError(f"Lean source module coverage changed: {sorted(actual_modules)}") diff --git a/formal/sonification/mat009/lean/verify.py b/formal/sonification/mat009/lean/verify.py index b8f826f..cec41b3 100644 --- a/formal/sonification/mat009/lean/verify.py +++ b/formal/sonification/mat009/lean/verify.py @@ -77,7 +77,11 @@ def verify(attempt: Path = DEFAULT_ATTEMPT, lean: Path | None = None) -> dict: result["theorem_declaration_count_including_generated"] == 95 and len(result["named_intended_theorems"]) == 22, "proof declaration count changed") - actual_modules = {p.name for p in HERE.rglob("*.lean")} + # Recovery contains archived reproductions, not active proof modules. + actual_modules = { + p.name for p in HERE.rglob("*.lean") + if "recovery" not in p.relative_to(HERE).parts + } require(actual_modules == {f"{module}.lean" for module in MODULES}, "current proof module coverage changed") for name, digest in result["input_sha256"].items(): From e1091de3bce9502ad333c530c1d7b12eb143f6da Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 12:27:54 +1030 Subject: [PATCH 18/22] formal(mat009): retain repaired Lean receipt and bind its verifier --- .../lean/attempts/003/EVIDENCE_MANIFEST.json | 30 + .../attempts/003/build-00-SplitModel.json | 15 + .../attempts/003/build-00-SplitModel.stderr | 0 .../attempts/003/build-00-SplitModel.stdout | 0 .../003/build-01-DiagnosticFirstOwner.json | 15 + .../003/build-01-DiagnosticFirstOwner.stderr | 0 .../003/build-01-DiagnosticFirstOwner.stdout | 0 .../attempts/003/build-02-TypedConsumer.json | 15 + .../003/build-02-TypedConsumer.stderr | 0 .../003/build-02-TypedConsumer.stdout | 71 + .../attempts/003/build-03-ExactTypes.json | 15 + .../attempts/003/build-03-ExactTypes.stderr | 0 .../attempts/003/build-03-ExactTypes.stdout | 0 .../lean/attempts/003/build-04-LeanAudit.json | 15 + .../attempts/003/build-04-LeanAudit.stderr | 0 .../attempts/003/build-04-LeanAudit.stdout | 1664 ++++++ .../lean/attempts/003/declarations.json | 4023 +++++++++++++ .../lean/attempts/003/lean-version.json | 12 + .../lean/attempts/003/lean-version.stderr | 0 .../lean/attempts/003/lean-version.stdout | 1 + .../lean/attempts/003/named-axioms.json | 62 + .../mat009/lean/attempts/003/result.json | 55 + .../lean/attempts/003/theorem-types.json | 24 + .../lean/attempts/003/toolchain-imports.json | 5214 +++++++++++++++++ formal/sonification/mat009/lean/negative.py | 2 +- formal/sonification/mat009/lean/verify.py | 6 +- 26 files changed, 11235 insertions(+), 4 deletions(-) create mode 100644 formal/sonification/mat009/lean/attempts/003/EVIDENCE_MANIFEST.json create mode 100644 formal/sonification/mat009/lean/attempts/003/build-00-SplitModel.json create mode 100644 formal/sonification/mat009/lean/attempts/003/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/attempts/003/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/attempts/003/build-01-DiagnosticFirstOwner.json create mode 100644 formal/sonification/mat009/lean/attempts/003/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/attempts/003/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/attempts/003/build-02-TypedConsumer.json create mode 100644 formal/sonification/mat009/lean/attempts/003/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/attempts/003/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/attempts/003/build-03-ExactTypes.json create mode 100644 formal/sonification/mat009/lean/attempts/003/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/lean/attempts/003/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/lean/attempts/003/build-04-LeanAudit.json create mode 100644 formal/sonification/mat009/lean/attempts/003/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/lean/attempts/003/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/lean/attempts/003/declarations.json create mode 100644 formal/sonification/mat009/lean/attempts/003/lean-version.json create mode 100644 formal/sonification/mat009/lean/attempts/003/lean-version.stderr create mode 100644 formal/sonification/mat009/lean/attempts/003/lean-version.stdout create mode 100644 formal/sonification/mat009/lean/attempts/003/named-axioms.json create mode 100644 formal/sonification/mat009/lean/attempts/003/result.json create mode 100644 formal/sonification/mat009/lean/attempts/003/theorem-types.json create mode 100644 formal/sonification/mat009/lean/attempts/003/toolchain-imports.json diff --git a/formal/sonification/mat009/lean/attempts/003/EVIDENCE_MANIFEST.json b/formal/sonification/mat009/lean/attempts/003/EVIDENCE_MANIFEST.json new file mode 100644 index 0000000..9a01897 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/EVIDENCE_MANIFEST.json @@ -0,0 +1,30 @@ +{ + "files_sha256": { + "build-00-SplitModel.json": "1fd04d47db0ceac9c351eb2c14445f25dbb00b5347305274b8fabb8bff0bc340", + "build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.json": "32a5119ca458d3acaf7ac1bd9545e9ae7fbd514a512342cff70af239ec809f0e", + "build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.json": "2b0d9d7a2cdeb9840264a69023ecbb701d094b5aefa73c7e7430f00d76f42fc0", + "build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "build-03-ExactTypes.json": "df1cdf37e609c57cc448e14ac4ef5a549f2e60009ac246558deb5113442c8172", + "build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.json": "579587fff4684d4d8227a0e7d7e3baa578da5bc1af8d7241acee488d09fd073c", + "build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.stdout": "fe581a6c34d4db092d539a74d23a263951dbc7c2c65b646962d62e5a1b3b7029", + "declarations.json": "b5ee7aff6fe16daa458cad083485b90a1a6c42073d7b588e4a32c99ed459742d", + "lean-version.json": "891fd7e9d7ca7393779b1eafec93925d0eb39390da8bb66ed47d2d72a5bd8d5b", + "lean-version.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "lean-version.stdout": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b", + "named-axioms.json": "d726df048cf1d5d7528afe2838eaa8a05b31b6a10c3b2a34109380b4bf779b1f", + "result.json": "9394ea8329d2447d97a07285c7bc7c757cf1723d2ef863332215d09675101112", + "theorem-types.json": "8ebc9839c12845f0410085754b475d7dd0ebf6c218869eebe39f2484104ddf5b", + "toolchain-imports.json": "69c9e85cad9c3ec024130bd80dc3e1fa6351053f135304268741bf1f0fd1b2ad" + }, + "proof_input_commit": "c562377308ebbb4694685076af12e79eefe0a479", + "schema": "sonification-mat009-lean-evidence-v1", + "scope": "checked eligible-row mathematical models; CPython refinement OPEN; compiler-suffix axiom gate repaired" +} diff --git a/formal/sonification/mat009/lean/attempts/003/build-00-SplitModel.json b/formal/sonification/mat009/lean/attempts/003/build-00-SplitModel.json new file mode 100644 index 0000000..4064344 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/build-00-SplitModel.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-bb16ogk2/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/003/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/attempts/003/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/003/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/attempts/003/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/003/build-01-DiagnosticFirstOwner.json b/formal/sonification/mat009/lean/attempts/003/build-01-DiagnosticFirstOwner.json new file mode 100644 index 0000000..e4e11ef --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/build-01-DiagnosticFirstOwner.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-bb16ogk2/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/003/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/attempts/003/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/003/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/attempts/003/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/003/build-02-TypedConsumer.json b/formal/sonification/mat009/lean/attempts/003/build-02-TypedConsumer.json new file mode 100644 index 0000000..6436b8c --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/build-02-TypedConsumer.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-bb16ogk2/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/003/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/attempts/003/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/003/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/attempts/003/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/attempts/003/build-03-ExactTypes.json b/formal/sonification/mat009/lean/attempts/003/build-03-ExactTypes.json new file mode 100644 index 0000000..60a9698 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/build-03-ExactTypes.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-bb16ogk2/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/003/build-03-ExactTypes.stderr b/formal/sonification/mat009/lean/attempts/003/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/003/build-03-ExactTypes.stdout b/formal/sonification/mat009/lean/attempts/003/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/003/build-04-LeanAudit.json b/formal/sonification/mat009/lean/attempts/003/build-04-LeanAudit.json new file mode 100644 index 0000000..b5fdee9 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/build-04-LeanAudit.json @@ -0,0 +1,15 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-lean-build-bb16ogk2/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/lean", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "fe581a6c34d4db092d539a74d23a263951dbc7c2c65b646962d62e5a1b3b7029", + "timed_out": false, + "timeout_seconds": 180 +} diff --git a/formal/sonification/mat009/lean/attempts/003/build-04-LeanAudit.stderr b/formal/sonification/mat009/lean/attempts/003/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/003/build-04-LeanAudit.stdout b/formal/sonification/mat009/lean/attempts/003/build-04-LeanAudit.stdout new file mode 100644 index 0000000..6778014 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/build-04-LeanAudit.stdout @@ -0,0 +1,1664 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.initial","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.initial._closed_1._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.initial._cstage1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.initial._cstage2","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":true,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"has_source_range":false,"declaration":"MAT009.initial._elambda_1","axioms":["MAT009.initial._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.initial._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.initial._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.initial.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.instDecidableEqRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"DecidableEq MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instDecidableEqRole._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instDecidableEqRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instDecidableEqRole._proof_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x y : MAT009.Role), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instDecidableEqRole._proof_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.instDecidableEqStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"DecidableEq MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instDecidableEqStatus._cstage1","axioms":["lcProof"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instDecidableEqStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx → x = y","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instDecidableEqStatus._proof_3","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x y : MAT009.Status), ¬x.toCtorIdx = y.toCtorIdx → x = y → False","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instDecidableEqStatus._proof_4","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.instReprRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instReprRole._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Repr MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instReprRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instReprRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.instReprRow","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instReprRow._closed_1._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Repr MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instReprRow._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instReprRow._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.instReprStatus","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instReprStatus._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Repr MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instReprStatus._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.instReprStatus._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.lastRole","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.lastRole._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.lastRole._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.lastRole._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"List MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.lastRole._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : String), MAT009.lastRole [] x = none","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.lastRole.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.lastRole.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.lastRole.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : Option MAT009.Role → Sort u_1) →\n (x : Option MAT009.Role) → ((role : MAT009.Role) → motive (some role)) → (Unit → motive none) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.lastRole.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.lastRole.match_2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.lastRole.match_2._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.leakageReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.leakageReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.leakageReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.leakageReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.leakageReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.noParent","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.ReasonSet","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.noParent._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.noParent._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : String), MAT009.noParent x = False","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.noParent.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout ∧\n s.campaigns MAT009.Role.train \"SAME\" ∧ s.campaigns MAT009.Role.holdout \"SAME\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.overwrite_retains_both_split_memberships","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason ∧ ¬(MAT009.finalize s).childReason MAT009.leakageReason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.parent_can_supply_leakage_reason","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (reason : String), s.parent reason → (MAT009.finalize s).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.parent_reason_survives_finalization","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → List MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State), MAT009.scan s [] = s","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) →\n (Unit → motive []) → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.scan_append","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key ↔\n s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.scan_campaigns_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan_campaigns_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan_campaigns_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan_campaigns_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan_campaigns_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), s.crossed → (MAT009.scan s rows).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.scan_crossed_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.scan s rows)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.scan_familyLeakage_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key ↔ s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.scan_labs_iff","axioms":["Quot.sound","propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan_labs_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan_labs_iff._proof_6","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {a b c : Prop}, (a ∨ b ∨ c) = (b ∨ a ∨ c)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan_labs_iff._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {a b : Prop}, (a ∨ b) = (b ∨ a)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.scan_labs_iff._proof_8","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.scan_owner_last","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason ↔ s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.scan_parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.Role → String → Prop) → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.splitIntersection","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (members : MAT009.Role → String → Prop),\n MAT009.splitIntersection members = ∃ key, members MAT009.Role.train key ∧ members MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.splitIntersection.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.step","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Row → MAT009.State","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.step._cstage1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.step._cstage2","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":true,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":true,"has_source_range":false,"declaration":"MAT009.step._elambda_1","axioms":["MAT009.step._elambda_1"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Row → String → Option MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.step._elambda_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.step._elambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key ∨ role = row.role ∧ key = row.campaign,\n labs := fun role key => s.labs role key ∨ role = row.role ∧ key = row.lab,\n crossed := s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role,\n parent := s.parent }","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.step.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String × MAT009.Diagnostic.Owner)) (h_1 : Unit → motive [])\n (h_2 :\n (identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n motive [] →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (x : String) (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (motive : List MAT009.Row → String → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) → motive [] x)\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : List MAT009.Row → String → Sort u_1) →\n (x : List MAT009.Row) →\n (x_1 : String) →\n ((x : String) → motive [] x) →\n ((row : MAT009.Row) → (rest : List MAT009.Row) → (key : String) → motive (row :: rest) key) → motive x x_1","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : MAT009.Role → Sort u_1) →\n (x : MAT009.Role) → (Unit → motive MAT009.Role.train) → (Unit → motive MAT009.Role.holdout) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.match_1.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Role → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRole.«_@».SplitModel._hyg.109._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_13._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_14._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_15._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_16._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_17._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_18._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_19._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_20._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_21._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Row → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage1","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprRow.«_@».SplitModel._hyg.221._cstage2","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : MAT009.Status → Sort u_1) →\n (x : MAT009.Status) →\n (Unit → motive MAT009.Status.blocked) → (Unit → motive MAT009.Status.structuralOnlyUnauthenticated) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.match_1.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_10._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_11._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_12._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._closed_9._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Status → Nat → Format","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.reprStatus.«_@».SplitModel._hyg.882._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (motive : List MAT009.Row → Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit → motive [])\n (h_2 : (row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : List MAT009.Row → Sort u_1) →\n (x : List MAT009.Row) → motive [] → ((row : MAT009.Row) → (rest : List MAT009.Row) → motive (row :: rest)) → motive x","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2","axioms":[]} +MAT009_AUDIT declarations=351 theorems=95 diff --git a/formal/sonification/mat009/lean/attempts/003/declarations.json b/formal/sonification/mat009/lean/attempts/003/declarations.json new file mode 100644 index 0000000..b78dc4c --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/declarations.json @@ -0,0 +1,4023 @@ +[ + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Consumer.parent_reason_blocks_any_scan", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "TypedConsumer", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Consumer.shared_campaign_blocks_any_scan", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "TypedConsumer", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = campaign) \u2192\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = campaign) \u2192\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.Owner", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "Type", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.Registry", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "Type", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.empty.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (x : String), MAT009.Diagnostic.empty x = none", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.first_owner_not_last_writer", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 String \u2192 MAT009.Diagnostic.Owner \u2192 MAT009.Diagnostic.Registry", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 String \u2192 MAT009.Diagnostic.Owner \u2192 MAT009.Diagnostic.Registry", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.match_1", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : Option MAT009.Diagnostic.Owner \u2192 Sort u_1) \u2192\n (x : Option MAT009.Diagnostic.Owner) \u2192\n (Unit \u2192 motive none) \u2192 ((first : MAT009.Diagnostic.Owner) \u2192 motive (some first)) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.register.match_1._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : Option MAT009.Diagnostic.Owner \u2192 Sort u_1) \u2192\n (x : Option MAT009.Diagnostic.Owner) \u2192\n (Unit \u2192 motive none) \u2192 ((first : MAT009.Diagnostic.Owner) \u2192 motive (some first)) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_first_owner", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first \u2192 MAT009.Diagnostic.register registry identity candidate identity = some first", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_new_owner", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none \u2192 MAT009.Diagnostic.register registry identity candidate identity = some candidate", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_other_identity", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key \u2260 identity \u2192 MAT009.Diagnostic.register registry identity candidate key = registry key", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.register_preserves_existing", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.register registry identity candidate key = some first", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._sunfold", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan._unsafe_rec", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "MAT009.Diagnostic.Registry \u2192 List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 MAT009.Diagnostic.Registry", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.eq_2", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.match_1", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n (Unit \u2192 motive []) \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Diagnostic.scan.match_1._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n (Unit \u2192 motive []) \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Diagnostic.scan_first_owner_sticky", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (registry : MAT009.Diagnostic.Registry) (updates : List (String \u00d7 MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.scan registry updates key = some first", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final._sizeOf_1", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Nat", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final._sizeOf_inst", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Final", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.casesOn", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n (t : MAT009.Final) \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.childReason", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 String \u2192 Prop", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.childReason.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason \u2227 f.crossed \u2228 reason = MAT009.leakageReason \u2227 f.leakage)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.crossed", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Prop", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.hasReason", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 String \u2192 Prop", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.hasReason.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason \u2228 f.childReason reason)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.leakage", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 Prop", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 Prop \u2192 Prop \u2192 MAT009.Final", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk._flat_ctor", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 Prop \u2192 Prop \u2192 MAT009.Final", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk.inj", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } \u2192\n parent = parent_1 \u2227 crossed = crossed_1 \u2227 leakage = leakage_1", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Final.mk.injEq", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 \u2227 crossed = crossed_1 \u2227 leakage = leakage_1)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.mk.sizeOf_spec", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.noConfusion", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.Final} \u2192 v1 = v2 \u2192 MAT009.Final.noConfusionType P v1 v2", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.noConfusionType", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.Final \u2192 MAT009.Final \u2192 Sort u", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.parent", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 MAT009.ReasonSet", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.rec", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n (t : MAT009.Final) \u2192 motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Final.recOn", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Final \u2192 Sort u} \u2192\n (t : MAT009.Final) \u2192\n ((parent : MAT009.ReasonSet) \u2192\n (crossed leakage : Prop) \u2192 motive { parent := parent, crossed := crossed, leakage := leakage }) \u2192\n motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Final \u2192 MAT009.Status", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final),\n f.status = if \u2203 reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status_blocked_iff", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final), f.status = MAT009.Status.blocked \u2194 \u2203 reason, f.hasReason reason", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.Final.status_structural_iff", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated \u2194 \u2200 (reason : String), \u00acf.hasReason reason", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Final.status_structural_iff._proof_5", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {p : \u03b1 \u2192 Prop}, (\u00ac\u2203 x, p x) = \u2200 (x : \u03b1), \u00acp x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R1_initial", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none \u2227\n \u00ac(MAT009.initial parent).campaigns role campaign \u2227\n \u00ac(MAT009.initial parent).labs role lab \u2227\n \u00ac(MAT009.initial parent).crossed \u2227 ((MAT009.initial parent).parent reason \u2194 parent reason)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R2_assignment_overwrite", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role \u2227\n (\u2200 (key : String), key \u2260 row.campaign \u2192 (MAT009.step s row).owner key = s.owner key) \u2227\n (\u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key \u2194 s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign) \u2227\n \u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key \u2194 s.labs role key \u2228 role = row.role \u2227 key = row.lab", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R3_cross_role_trigger", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed \u2194 s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R4_stickiness", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign \u2192 (MAT009.step s row).campaigns role campaign) \u2227\n (s.labs role lab \u2192 (MAT009.step s row).labs role lab) \u2227\n (s.crossed \u2192 (MAT009.step s row).crossed) \u2227\n (MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)) \u2227\n ((MAT009.step s row).parent reason \u2194 s.parent reason)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R5_final_set_intersection", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason \u2194\n (\u2203 key, s.campaigns MAT009.Role.train key \u2227 s.campaigns MAT009.Role.holdout key) \u2228\n \u2203 key, s.labs MAT009.Role.train key \u2227 s.labs MAT009.Role.holdout key", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R5_parent_union", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason \u2194 s.parent MAT009.leakageReason \u2228 MAT009.familyLeakage s", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign \u2194\n \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = campaign) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab \u2194 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = lab) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).parent reason \u2194 parent reason)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_5", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_6", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_arbitrary_finite_scan._proof_7", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_cross_trigger_in_finite_scan", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (\u2203 previous, (MAT009.scan s before).owner row.campaign = some previous \u2227 previous \u2260 row.role) \u2192\n (MAT009.scan s (before ++ row :: after)).crossed", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason \u2194\n (\u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = key) \u2228\n \u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.lab = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.lab = key", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff._proof_5", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R6_final_leakage_iff._proof_6", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.M009_R6_latest_owner", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.M009_R6_parent_reason_survives", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_accepted_example", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_nonvacuous", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(\u2203 rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) \u2227\n \u2203 rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Classical.choice", + "propext", + "Quot.sound" + ], + "declaration": "MAT009.M009_R7_rejected_example", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.ReasonSet", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role._sizeOf_1", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role._sizeOf_inst", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.casesOn", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 (t : MAT009.Role) \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.holdout", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.holdout.sizeOf_spec", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Role.holdout = 1", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Role} \u2192 x = y \u2192 MAT009.Role.noConfusionType P x y", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "lcUnreachable" + ], + "declaration": "MAT009.Role.noConfusion._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Role} \u2192 x = y \u2192 MAT009.Role.noConfusionType P x y", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 _neutral \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusion._rarg._lambda_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.noConfusionType", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort v\u271d \u2192 MAT009.Role \u2192 MAT009.Role \u2192 Sort v\u271d", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 UInt8", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.ofNat_toCtorIdx", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.rec", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 (t : MAT009.Role) \u2192 motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.recOn", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Role \u2192 Sort u} \u2192 (t : MAT009.Role) \u2192 motive MAT009.Role.train \u2192 motive MAT009.Role.holdout \u2192 motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.toCtorIdx._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Role.train", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Role.train.sizeOf_spec", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Role.train = 1", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row._sizeOf_1", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row._sizeOf_inst", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Row", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.campaign", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 String", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.casesOn", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n (t : MAT009.Row) \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.lab", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 String", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String \u2192 String \u2192 MAT009.Role \u2192 MAT009.Row", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk._flat_ctor", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String \u2192 String \u2192 MAT009.Role \u2192 MAT009.Row", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk.inj", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } \u2192\n campaign = campaign_1 \u2227 lab = lab_1 \u2227 role = role_1", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.Row.mk.injEq", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 \u2227 lab = lab_1 \u2227 role = role_1)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.mk.sizeOf_spec", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.noConfusion", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.Row} \u2192 v1 = v2 \u2192 MAT009.Row.noConfusionType P v1 v2", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.noConfusionType", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.Row \u2192 MAT009.Row \u2192 Sort u", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.rec", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n (t : MAT009.Row) \u2192 motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.recOn", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Row \u2192 Sort u} \u2192\n (t : MAT009.Row) \u2192\n ((campaign lab : String) \u2192 (role : MAT009.Role) \u2192 motive { campaign := campaign, lab := lab, role := role }) \u2192\n motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Row.role", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State._sizeOf_1", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Nat", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State._sizeOf_inst", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.State", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.campaigns", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Role \u2192 String \u2192 Prop", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.casesOn", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n (t : MAT009.State) \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.crossed", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Prop", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.labs", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Role \u2192 String \u2192 Prop", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(String \u2192 Option MAT009.Role) \u2192\n (MAT009.Role \u2192 String \u2192 Prop) \u2192 (MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop \u2192 MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk._flat_ctor", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(String \u2192 Option MAT009.Role) \u2192\n (MAT009.Role \u2192 String \u2192 Prop) \u2192 (MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop \u2192 MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk.inj", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {owner : String \u2192 Option MAT009.Role} {campaigns labs : MAT009.Role \u2192 String \u2192 Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String \u2192 Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role \u2192 String \u2192 Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } \u2192\n owner = owner_1 \u2227 campaigns = campaigns_1 \u2227 labs = labs_1 \u2227 crossed = crossed_1 \u2227 parent = parent_1", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.State.mk.injEq", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (owner : String \u2192 Option MAT009.Role) (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String \u2192 Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role \u2192 String \u2192 Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 \u2227 campaigns = campaigns_1 \u2227 labs = labs_1 \u2227 crossed = crossed_1 \u2227 parent = parent_1)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.mk.sizeOf_spec", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (owner : String \u2192 Option MAT009.Role) (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.noConfusion", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort u} \u2192 {v1 v2 : MAT009.State} \u2192 v1 = v2 \u2192 MAT009.State.noConfusionType P v1 v2", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.noConfusionType", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort u \u2192 MAT009.State \u2192 MAT009.State \u2192 Sort u", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.owner", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 String \u2192 Option MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.parent", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.ReasonSet", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.rec", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n (t : MAT009.State) \u2192 motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.State.recOn", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.State \u2192 Sort u} \u2192\n (t : MAT009.State) \u2192\n ((owner : String \u2192 Option MAT009.Role) \u2192\n (campaigns labs : MAT009.Role \u2192 String \u2192 Prop) \u2192\n (crossed : Prop) \u2192\n (parent : MAT009.ReasonSet) \u2192\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) \u2192\n motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Type", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status._sizeOf_1", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status._sizeOf_inst", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "SizeOf MAT009.Status", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.blocked", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.blocked.sizeOf_spec", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Status.blocked = 1", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.casesOn", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n (t : MAT009.Status) \u2192 motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Status} \u2192 x = y \u2192 MAT009.Status.noConfusionType P x y", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "lcUnreachable" + ], + "declaration": "MAT009.Status.noConfusion._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "{P : Sort v\u271d} \u2192 {x y : MAT009.Status} \u2192 x = y \u2192 MAT009.Status.noConfusionType P x y", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusion._rarg._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 _neutral \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.noConfusionType", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Sort v\u271d \u2192 MAT009.Status \u2192 MAT009.Status \u2192 Sort v\u271d", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Status", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Nat \u2192 MAT009.Status", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 UInt8", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.ofNat_toCtorIdx", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.rec", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 (t : MAT009.Status) \u2192 motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.recOn", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "{motive : MAT009.Status \u2192 Sort u} \u2192\n (t : MAT009.Status) \u2192 motive MAT009.Status.blocked \u2192 motive MAT009.Status.structuralOnlyUnauthenticated \u2192 motive t", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.structuralOnlyUnauthenticated", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.Status.toCtorIdx._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_2._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_3._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_4._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_5._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_6._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_7._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._closed_8._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.cleanRows.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossReason", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossReason.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_2._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_3._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_4._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._closed_5._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.crossingRows.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 Prop", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns \u2228 MAT009.splitIntersection s.labs)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.familyLeakage_step_sticky", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.finalize", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Final", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.finalize._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Final", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.finalize._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.finalize.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.initial", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.ReasonSet \u2192 MAT009.State", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.initial._elambda_1" + ], + "declaration": "MAT009.initial._elambda_1", + "has_source_range": false, + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String \u2192 Option MAT009.Role", + "unsafe_axiom": true, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.initial._elambda_1._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String \u2192 Option MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.initial._elambda_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.initial.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (parent : MAT009.ReasonSet),\n MAT009.initial parent =\n { owner := fun x => none, campaigns := fun x x => False, labs := fun x x => False, crossed := False,\n parent := parent }", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "lcProof" + ], + "declaration": "MAT009.instDecidableEqRole._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 UInt8", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._proof_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Role), x.toCtorIdx = y.toCtorIdx \u2192 x = y", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqRole._proof_2", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Role), \u00acx.toCtorIdx = y.toCtorIdx \u2192 x = y \u2192 False", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Status", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "lcProof" + ], + "declaration": "MAT009.instDecidableEqStatus._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "DecidableEq MAT009.Status", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 UInt8 \u2192 UInt8", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._proof_3", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Status), x.toCtorIdx = y.toCtorIdx \u2192 x = y", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instDecidableEqStatus._proof_4", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x y : MAT009.Status), \u00acx.toCtorIdx = y.toCtorIdx \u2192 x = y \u2192 False", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprRole._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Row", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Row", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.instReprRow._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "Repr MAT009.Status", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "Repr MAT009.Status", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.instReprStatus._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._sunfold", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole._unsafe_rec", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "List MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String), MAT009.lastRole [] x = none", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.eq_2", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.lastRole (row :: rest) x =\n match MAT009.lastRole rest x with\n | some role => some role\n | none => if row.campaign = x then some row.role else none", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_1", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : Option MAT009.Role \u2192 Sort u_1) \u2192\n (x : Option MAT009.Role) \u2192 ((role : MAT009.Role) \u2192 motive (some role)) \u2192 (Unit \u2192 motive none) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_1._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : Option MAT009.Role \u2192 Sort u_1) \u2192\n (x : Option MAT009.Role) \u2192 ((role : MAT009.Role) \u2192 motive (some role)) \u2192 (Unit \u2192 motive none) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_2", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.lastRole.match_2._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "String", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "String", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.leakageReason.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "MAT009.leakageReason = \"SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS\"", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.noParent", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.ReasonSet", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.noParent._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.ReasonSet", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.noParent._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.noParent.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (x : String), MAT009.noParent x = False", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.overwrite_retains_both_split_memberships", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "let s := MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows;\ns.owner \"SAME\" = some MAT009.Role.holdout \u2227\n s.campaigns MAT009.Role.train \"SAME\" \u2227 s.campaigns MAT009.Role.holdout \"SAME\"", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.parent_can_supply_leakage_reason", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "let s := MAT009.initial fun reason => reason = MAT009.leakageReason;\n(MAT009.finalize s).hasReason MAT009.leakageReason \u2227 \u00ac(MAT009.finalize s).childReason MAT009.leakageReason", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.parent_reason_survives_finalization", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (reason : String), s.parent reason \u2192 (MAT009.finalize s).hasReason reason", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.scan._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.scan._sunfold", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan._unsafe_rec", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 List MAT009.Row \u2192 MAT009.State", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State), MAT009.scan s [] = s", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.eq_2", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row) (rest : List MAT009.Row),\n MAT009.scan s (row :: rest) = MAT009.scan (MAT009.step s row) rest", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.match_1", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (Unit \u2192 motive []) \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan.match_1._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (Unit \u2192 motive []) \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.scan_append", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (before after : List MAT009.Row),\n MAT009.scan s (before ++ after) = MAT009.scan (MAT009.scan s before) after", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key \u2194\n s.campaigns role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = key", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_5", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {a b : \u03b1}, (a = b) = (b = a)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_6", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, ((a \u2228 b) \u2228 c) = (a \u2228 b \u2228 c)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_7", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, (a \u2228 b \u2228 c) = (b \u2228 a \u2228 c)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_campaigns_iff._proof_8", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b : Prop}, (a \u2228 b) = (b \u2228 a)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_crossed_sticky", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row), s.crossed \u2192 (MAT009.scan s rows).crossed", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_familyLeakage_sticky", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row), MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.scan s rows)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "Quot.sound", + "propext" + ], + "declaration": "MAT009.scan_labs_iff", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key \u2194 s.labs role key \u2228 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = key", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_5", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {\u03b1 : Sort u_1} {a b : \u03b1}, (a = b) = (b = a)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_6", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, ((a \u2228 b) \u2228 c) = (a \u2228 b \u2228 c)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_7", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b c : Prop}, (a \u2228 b \u2228 c) = (b \u2228 a \u2228 c)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_labs_iff._proof_8", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 {a b : Prop}, (a \u2228 b) = (b \u2228 a)", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "propext" + ], + "declaration": "MAT009.scan_owner_last", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (key : String),\n (MAT009.scan s rows).owner key =\n match MAT009.lastRole rows key with\n | some role => some role\n | none => s.owner key", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.scan_parent", + "has_source_range": true, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason \u2194 s.parent reason", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.splitIntersection", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(MAT009.Role \u2192 String \u2192 Prop) \u2192 Prop", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.splitIntersection.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (members : MAT009.Role \u2192 String \u2192 Prop),\n MAT009.splitIntersection members = \u2203 key, members MAT009.Role.train key \u2227 members MAT009.Role.holdout key", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.step", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 MAT009.State", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 MAT009.State", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "MAT009.step._elambda_1" + ], + "declaration": "MAT009.step._elambda_1", + "has_source_range": false, + "is_axiom": true, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_axiom": true, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "MAT009.step._elambda_1._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.State \u2192 MAT009.Row \u2192 String \u2192 Option MAT009.Role", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.step._elambda_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "MAT009.step.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n MAT009.step s row =\n { owner := fun key => if key = row.campaign then some row.role else s.owner key,\n campaigns := fun role key => s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign,\n labs := fun role key => s.labs role key \u2228 role = row.role \u2227 key = row.lab,\n crossed := s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role,\n parent := s.parent }", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) (h_1 : Unit \u2192 motive [])\n (h_2 :\n (identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)),\n (match [] with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_1 ()", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.eq_2", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "DiagnosticFirstOwner", + "type": "\u2200 (motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) (identity : String)\n (candidate : MAT009.Diagnostic.Owner) (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) (h_1 : Unit \u2192 motive [])\n (h_2 :\n (identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)),\n (match (identity, candidate) :: rest with\n | [] => h_1 ()\n | (identity, candidate) :: rest => h_2 identity candidate rest) =\n h_2 identity candidate rest", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n motive [] \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "(motive : List (String \u00d7 MAT009.Diagnostic.Owner) \u2192 Sort u_1) \u2192\n (x : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192\n motive [] \u2192\n ((identity : String) \u2192\n (candidate : MAT009.Diagnostic.Owner) \u2192\n (rest : List (String \u00d7 MAT009.Diagnostic.Owner)) \u2192 motive ((identity, candidate) :: rest)) \u2192\n motive x", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_neutral \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.DiagnosticFirstOwner.0.MAT009.Diagnostic.scan.match_1.splitter._rarg._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "DiagnosticFirstOwner", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 String \u2192 Sort u_1) (x : String) (h_1 : (x : String) \u2192 motive [] x)\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key),\n (match [], x with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_1 x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.eq_2", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 String \u2192 Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (key : String)\n (h_1 : (x : String) \u2192 motive [] x)\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key),\n (match row :: rest, key with\n | [], x => h_1 x\n | row :: rest, key => h_2 row rest key) =\n h_2 row rest key", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 String \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192\n (x_1 : String) \u2192\n ((x : String) \u2192 motive [] x) \u2192\n ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 (key : String) \u2192 motive (row :: rest) key) \u2192 motive x x_1", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.lastRole.match_2.splitter._rarg._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole._@.SplitModel._hyg.109", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat \u2192 Format", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.match_1._@.SplitModel._hyg.109", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : MAT009.Role \u2192 Sort u_1) \u2192\n (x : MAT009.Role) \u2192 (Unit \u2192 motive MAT009.Role.train) \u2192 (Unit \u2192 motive MAT009.Role.holdout) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.match_1.\u00ab_@\u00bb.SplitModel._hyg.109._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : MAT009.Role \u2192 Sort u_1) \u2192\n (x : MAT009.Role) \u2192 (Unit \u2192 motive MAT009.Role.train) \u2192 (Unit \u2192 motive MAT009.Role.holdout) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_10._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_11._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_12._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_13._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_14._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_2._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_3._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_4._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_5._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_6._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_7._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_8._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._closed_9._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Role \u2192 Nat \u2192 Format", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRole.\u00ab_@\u00bb.SplitModel._hyg.109._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow._@.SplitModel._hyg.221", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat \u2192 Format", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_10._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_11._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_12._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_13._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_14._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_15._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_16._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_17._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_18._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_19._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_2._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_20._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_21._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_3._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_4._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_5._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_6._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_7._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_8._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._closed_9._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Row \u2192 Nat \u2192 Format", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [ + "propext" + ], + "declaration": "_private.SplitModel.0.MAT009.reprRow.\u00ab_@\u00bb.SplitModel._hyg.221._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus._@.SplitModel._hyg.882", + "has_source_range": true, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat \u2192 Format", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.match_1._@.SplitModel._hyg.882", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : MAT009.Status \u2192 Sort u_1) \u2192\n (x : MAT009.Status) \u2192\n (Unit \u2192 motive MAT009.Status.blocked) \u2192 (Unit \u2192 motive MAT009.Status.structuralOnlyUnauthenticated) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.match_1.\u00ab_@\u00bb.SplitModel._hyg.882._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : MAT009.Status \u2192 Sort u_1) \u2192\n (x : MAT009.Status) \u2192\n (Unit \u2192 motive MAT009.Status.blocked) \u2192 (Unit \u2192 motive MAT009.Status.structuralOnlyUnauthenticated) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_1._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_10._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_11._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_12._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_2._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_3._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_4._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_5._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_6._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_7._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_8._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._closed_9._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "MAT009.Status \u2192 Nat \u2192 Format", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.reprStatus.\u00ab_@\u00bb.SplitModel._hyg.882._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "UInt8 \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.eq_1", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 Sort u_1) (h_1 : Unit \u2192 motive [])\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)),\n (match [] with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_1 ()", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.eq_2", + "has_source_range": false, + "is_axiom": false, + "kind": "theorem", + "origin": "SplitModel", + "type": "\u2200 (motive : List MAT009.Row \u2192 Sort u_1) (row : MAT009.Row) (rest : List MAT009.Row) (h_1 : Unit \u2192 motive [])\n (h_2 : (row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)),\n (match row :: rest with\n | [] => h_1 ()\n | row :: rest => h_2 row rest) =\n h_2 row rest", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter", + "has_source_range": false, + "is_axiom": false, + "kind": "non_theorem", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192 motive [] \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": false + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage1", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "(motive : List MAT009.Row \u2192 Sort u_1) \u2192\n (x : List MAT009.Row) \u2192 motive [] \u2192 ((row : MAT009.Row) \u2192 (rest : List MAT009.Row) \u2192 motive (row :: rest)) \u2192 motive x", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_neutral \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + }, + { + "axioms": [], + "declaration": "_private.SplitModel.0.MAT009.scan.match_1.splitter._rarg._cstage2", + "has_source_range": false, + "is_axiom": false, + "kind": "compiler_auxiliary", + "origin": "SplitModel", + "type": "_obj \u2192 _obj \u2192 _obj \u2192 _obj", + "unsafe_axiom": false, + "unsafe_definition": true + } +] diff --git a/formal/sonification/mat009/lean/attempts/003/lean-version.json b/formal/sonification/mat009/lean/attempts/003/lean-version.json new file mode 100644 index 0000000..10f4b46 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/lean-version.json @@ -0,0 +1,12 @@ +{ + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--version" + ], + "cwd": "/home/trent/sonification-formal-001-mat009", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "5362a246ce2545424db10a77de8fd4694f4cf8b0170dfd43fa727acf7f7f259b", + "timed_out": false, + "timeout_seconds": 30 +} diff --git a/formal/sonification/mat009/lean/attempts/003/lean-version.stderr b/formal/sonification/mat009/lean/attempts/003/lean-version.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/attempts/003/lean-version.stdout b/formal/sonification/mat009/lean/attempts/003/lean-version.stdout new file mode 100644 index 0000000..507e58d --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/lean-version.stdout @@ -0,0 +1 @@ +Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release) diff --git a/formal/sonification/mat009/lean/attempts/003/named-axioms.json b/formal/sonification/mat009/lean/attempts/003/named-axioms.json new file mode 100644 index 0000000..41676d1 --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/named-axioms.json @@ -0,0 +1,62 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Consumer.shared_campaign_blocks_any_scan": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.Diagnostic.first_owner_not_last_writer": [ + "propext" + ], + "MAT009.Diagnostic.scan_first_owner_sticky": [ + "propext" + ], + "MAT009.M009_R1_initial": [ + "propext" + ], + "MAT009.M009_R2_assignment_overwrite": [ + "propext" + ], + "MAT009.M009_R3_cross_role_trigger": [], + "MAT009.M009_R4_stickiness": [], + "MAT009.M009_R5_final_set_intersection": [ + "propext" + ], + "MAT009.M009_R5_parent_union": [ + "propext" + ], + "MAT009.M009_R6_arbitrary_finite_scan": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_cross_trigger_in_finite_scan": [ + "propext" + ], + "MAT009.M009_R6_final_leakage_iff": [ + "Quot.sound", + "propext" + ], + "MAT009.M009_R6_latest_owner": [ + "propext" + ], + "MAT009.M009_R6_parent_reason_survives": [], + "MAT009.M009_R7_accepted_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_nonvacuous": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "MAT009.M009_R7_rejected_example": [ + "Classical.choice", + "Quot.sound", + "propext" + ] +} diff --git a/formal/sonification/mat009/lean/attempts/003/result.json b/formal/sonification/mat009/lean/attempts/003/result.json new file mode 100644 index 0000000..f5318ab --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/result.json @@ -0,0 +1,55 @@ +{ + "AUDIT_ACCEPTED": "OPEN", + "DIFFERENTIAL_TESTED": "NOT_EXECUTED", + "MODEL_PROVED": "PASS_FOR_SCOPED_MATHEMATICAL_MODEL", + "REFINEMENT_PROVED": "OPEN", + "baseline_commit": "c562377308ebbb4694685076af12e79eefe0a479", + "compiler_auxiliary_count": 146, + "completed_utc": "2026-11-10T01:57:09.579284+00:00", + "declaration_count": 351, + "external_import_count": 1303, + "input_sha256": { + "DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "LeanAudit.lean": "867bb9c70345c525239e6cadd6da3ec1f186f586f431855de67aadefa429882c", + "PROOF_NOTES.md": "59e1de6f61167b05aaf259ea5f10090606c8d341974945d9fd6daeaed00ced9a", + "SplitModel.lean": "2d6f80e9749e846db5f7c54bcc189c1ae3f345e19677842c002c2bea69790795", + "TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa", + "check.py": "0b9d4e3b76f7d122c2225c3d727791159b7945454d2dc9ccab55e89286de51b2", + "lean-toolchain": "55e97be96000b5e9e290c9e74482e5e317861499a5540353ce845471bded8cea" + }, + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "lean_version": "Lean (version 4.19.0, x86_64-unknown-linux-gnu, commit 6caaee842e94, Release)", + "logical_axioms": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "named_intended_theorems": [ + "MAT009.Consumer.parent_reason_blocks_any_scan", + "MAT009.Consumer.shared_campaign_blocks_any_scan", + "MAT009.Diagnostic.first_owner_not_last_writer", + "MAT009.Diagnostic.register_first_owner", + "MAT009.Diagnostic.register_new_owner", + "MAT009.Diagnostic.register_other_identity", + "MAT009.Diagnostic.register_preserves_existing", + "MAT009.Diagnostic.scan_first_owner_sticky", + "MAT009.M009_R1_initial", + "MAT009.M009_R2_assignment_overwrite", + "MAT009.M009_R3_cross_role_trigger", + "MAT009.M009_R4_stickiness", + "MAT009.M009_R5_final_set_intersection", + "MAT009.M009_R5_parent_union", + "MAT009.M009_R6_arbitrary_finite_scan", + "MAT009.M009_R6_cross_trigger_in_finite_scan", + "MAT009.M009_R6_final_leakage_iff", + "MAT009.M009_R6_latest_owner", + "MAT009.M009_R6_parent_reason_survives", + "MAT009.M009_R7_accepted_example", + "MAT009.M009_R7_nonvacuous", + "MAT009.M009_R7_rejected_example" + ], + "started_utc": "2026-11-10T01:56:50.362724+00:00", + "status": "PASS", + "theorem_declaration_count_including_generated": 95 +} diff --git a/formal/sonification/mat009/lean/attempts/003/theorem-types.json b/formal/sonification/mat009/lean/attempts/003/theorem-types.json new file mode 100644 index 0000000..1eb358e --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/theorem-types.json @@ -0,0 +1,24 @@ +{ + "MAT009.Consumer.parent_reason_blocks_any_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "MAT009.Consumer.shared_campaign_blocks_any_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = campaign) \u2192\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = campaign) \u2192\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked", + "MAT009.Diagnostic.first_owner_not_last_writer": "MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")", + "MAT009.Diagnostic.register_first_owner": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first \u2192 MAT009.Diagnostic.register registry identity candidate identity = some first", + "MAT009.Diagnostic.register_new_owner": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none \u2192 MAT009.Diagnostic.register registry identity candidate identity = some candidate", + "MAT009.Diagnostic.register_other_identity": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key \u2260 identity \u2192 MAT009.Diagnostic.register registry identity candidate key = registry key", + "MAT009.Diagnostic.register_preserves_existing": "\u2200 (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.register registry identity candidate key = some first", + "MAT009.Diagnostic.scan_first_owner_sticky": "\u2200 (registry : MAT009.Diagnostic.Registry) (updates : List (String \u00d7 MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first \u2192 MAT009.Diagnostic.scan registry updates key = some first", + "MAT009.M009_R1_initial": "\u2200 (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none \u2227\n \u00ac(MAT009.initial parent).campaigns role campaign \u2227\n \u00ac(MAT009.initial parent).labs role lab \u2227\n \u00ac(MAT009.initial parent).crossed \u2227 ((MAT009.initial parent).parent reason \u2194 parent reason)", + "MAT009.M009_R2_assignment_overwrite": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role \u2227\n (\u2200 (key : String), key \u2260 row.campaign \u2192 (MAT009.step s row).owner key = s.owner key) \u2227\n (\u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key \u2194 s.campaigns role key \u2228 role = row.role \u2227 key = row.campaign) \u2227\n \u2200 (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key \u2194 s.labs role key \u2228 role = row.role \u2227 key = row.lab", + "MAT009.M009_R3_cross_role_trigger": "\u2200 (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed \u2194 s.crossed \u2228 \u2203 previous, s.owner row.campaign = some previous \u2227 previous \u2260 row.role", + "MAT009.M009_R4_stickiness": "\u2200 (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign \u2192 (MAT009.step s row).campaigns role campaign) \u2227\n (s.labs role lab \u2192 (MAT009.step s row).labs role lab) \u2227\n (s.crossed \u2192 (MAT009.step s row).crossed) \u2227\n (MAT009.familyLeakage s \u2192 MAT009.familyLeakage (MAT009.step s row)) \u2227\n ((MAT009.step s row).parent reason \u2194 s.parent reason)", + "MAT009.M009_R5_final_set_intersection": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason \u2194\n (\u2203 key, s.campaigns MAT009.Role.train key \u2227 s.campaigns MAT009.Role.holdout key) \u2228\n \u2203 key, s.labs MAT009.Role.train key \u2227 s.labs MAT009.Role.holdout key", + "MAT009.M009_R5_parent_union": "\u2200 (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason \u2194 s.parent MAT009.leakageReason \u2228 MAT009.familyLeakage s", + "MAT009.M009_R6_arbitrary_finite_scan": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign \u2194\n \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.campaign = campaign) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab \u2194 \u2203 row, row \u2208 rows \u2227 row.role = role \u2227 row.lab = lab) \u2227\n ((MAT009.scan (MAT009.initial parent) rows).parent reason \u2194 parent reason)", + "MAT009.M009_R6_cross_trigger_in_finite_scan": "\u2200 (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (\u2203 previous, (MAT009.scan s before).owner row.campaign = some previous \u2227 previous \u2260 row.role) \u2192\n (MAT009.scan s (before ++ row :: after)).crossed", + "MAT009.M009_R6_final_leakage_iff": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason \u2194\n (\u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.campaign = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.campaign = key) \u2228\n \u2203 key,\n (\u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.train \u2227 row.lab = key) \u2227\n \u2203 row, row \u2208 rows \u2227 row.role = MAT009.Role.holdout \u2227 row.lab = key", + "MAT009.M009_R6_latest_owner": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign", + "MAT009.M009_R6_parent_reason_survives": "\u2200 (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason \u2192 (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason", + "MAT009.M009_R7_accepted_example": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated", + "MAT009.M009_R7_nonvacuous": "(\u2203 rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) \u2227\n \u2203 rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked", + "MAT009.M009_R7_rejected_example": "(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked" +} diff --git a/formal/sonification/mat009/lean/attempts/003/toolchain-imports.json b/formal/sonification/mat009/lean/attempts/003/toolchain-imports.json new file mode 100644 index 0000000..e56b85e --- /dev/null +++ b/formal/sonification/mat009/lean/attempts/003/toolchain-imports.json @@ -0,0 +1,5214 @@ +{ + "Init": { + "relative_path": "lib/lean/Init.olean", + "sha256": "f14f6c9ea0d9eb2a6fe7bdad84a6610657db3d006805708c1a62ac72b676e944" + }, + "Init.BinderNameHint": { + "relative_path": "lib/lean/Init/BinderNameHint.olean", + "sha256": "87ad3f24763ab6293e9907bd53fd2c87397a1bcc41741d496530391424f397f0" + }, + "Init.BinderPredicates": { + "relative_path": "lib/lean/Init/BinderPredicates.olean", + "sha256": "b87d6204d662e2164c4ccac16ffe6ef34c17e46473219f7615a8e5a902f88399" + }, + "Init.ByCases": { + "relative_path": "lib/lean/Init/ByCases.olean", + "sha256": "a446cd54c7d9b5cd764bac51e0e86bdbfd92cceb559a0ce174c8bfdd0880031f" + }, + "Init.Classical": { + "relative_path": "lib/lean/Init/Classical.olean", + "sha256": "146557a1d2b3d89dccc8a37db0eaf2ca41b7e8b7e9699cc1d2040209ab2d5206" + }, + "Init.Coe": { + "relative_path": "lib/lean/Init/Coe.olean", + "sha256": "8264daae9323339b7a0e4648e9054bc4d6bfa2ed2efe3bbf60f3ed4c85ededf1" + }, + "Init.Control": { + "relative_path": "lib/lean/Init/Control.olean", + "sha256": "02b03cb26d015878cb086d2aa9619d028653c4d7b13f7d27defa18c526f59acf" + }, + "Init.Control.Basic": { + "relative_path": "lib/lean/Init/Control/Basic.olean", + "sha256": "770f96586bd33c585cba7ae023b9ba455fdbcc6656008a7ae44921a2a381e673" + }, + "Init.Control.EState": { + "relative_path": "lib/lean/Init/Control/EState.olean", + "sha256": "bf304f9ebac42bc1e0604ed85fd34ccfbfb1d48c36a0378264daa004c7b1663a" + }, + "Init.Control.Except": { + "relative_path": "lib/lean/Init/Control/Except.olean", + "sha256": "2df44aacfe3c18de279a500ce89ca07fdaae3ac41ee5e13753f675ffcee590bf" + }, + "Init.Control.ExceptCps": { + "relative_path": "lib/lean/Init/Control/ExceptCps.olean", + "sha256": "abf85a131ec12cc4943351cd8e94d25a8ea643d8aed05e3174ddf102a92c82ab" + }, + "Init.Control.Id": { + "relative_path": "lib/lean/Init/Control/Id.olean", + "sha256": "3bdbaf6aab9ebd5bc7f69df7ea3817d60fe3e93621ceac45998aeada2ab0f2fb" + }, + "Init.Control.Lawful": { + "relative_path": "lib/lean/Init/Control/Lawful.olean", + "sha256": "d0e4de63caa049aa63032c262df55cb6e05decd6a639b3197d03a94bfb9cf630" + }, + "Init.Control.Lawful.Basic": { + "relative_path": "lib/lean/Init/Control/Lawful/Basic.olean", + "sha256": "2e5796aeb855144054fe96c87df8c1942fe57363ca46616dd713602e9e83008e" + }, + "Init.Control.Lawful.Instances": { + "relative_path": "lib/lean/Init/Control/Lawful/Instances.olean", + "sha256": "3a42743efc08488094315361697052bbea44791dc9b26bb42a7687be82351798" + }, + "Init.Control.Lawful.Lemmas": { + "relative_path": "lib/lean/Init/Control/Lawful/Lemmas.olean", + "sha256": "872c79b884079a180f2cb4efe5d5ccfd86e8231040ccf0286fdc0ae3e48de6cb" + }, + "Init.Control.Option": { + "relative_path": "lib/lean/Init/Control/Option.olean", + "sha256": "2fd4fd3d76c35d38f22bbd43287b2034db3fc09e9db40a72d64766fc2e1a27cf" + }, + "Init.Control.Reader": { + "relative_path": "lib/lean/Init/Control/Reader.olean", + "sha256": "0ee81ccf6c24215ac02fbddbc47f9d0ec88154c747938db879dc176e84cab35c" + }, + "Init.Control.State": { + "relative_path": "lib/lean/Init/Control/State.olean", + "sha256": "9967249936b6e2882f7c6551ed25b8c11c499e5146884f43c851019a9212b58e" + }, + "Init.Control.StateCps": { + "relative_path": "lib/lean/Init/Control/StateCps.olean", + "sha256": "a7e465f72965884c566492bf128ce366f9b6259feb3ff78a2dc7941276668910" + }, + "Init.Control.StateRef": { + "relative_path": "lib/lean/Init/Control/StateRef.olean", + "sha256": "4c48d97631e2c887a9109f0a3b11930e960674722db2d7ec96228ebb4cebc397" + }, + "Init.Conv": { + "relative_path": "lib/lean/Init/Conv.olean", + "sha256": "27e368664cd48cc7db0b6d8b936fcf3bd3b0c8652d67c7d72ed1a70e481c2cae" + }, + "Init.Core": { + "relative_path": "lib/lean/Init/Core.olean", + "sha256": "325d3e1934d1e99dbf7bde7643d6b1a582e0e98a2bc67156ecbfb1e044c81b62" + }, + "Init.Data": { + "relative_path": "lib/lean/Init/Data.olean", + "sha256": "e0fb356d8ff226c74733d563a2fddfd5d3f9031353f07eab9316189729ea0b05" + }, + "Init.Data.AC": { + "relative_path": "lib/lean/Init/Data/AC.olean", + "sha256": "c31d122ca9a36ebccfade139b5d01a27520cfe5da9c13fbcee0de6afc18e6e2e" + }, + "Init.Data.Array": { + "relative_path": "lib/lean/Init/Data/Array.olean", + "sha256": "628b1fe1e5028d01279c0e4b94f8a75a5404c5c2c62f56cb0f2f93e949b871fe" + }, + "Init.Data.Array.Attach": { + "relative_path": "lib/lean/Init/Data/Array/Attach.olean", + "sha256": "17dd10a433d8c5eefec2380008930b9db90cf5baaf6a111862d248280489809b" + }, + "Init.Data.Array.Basic": { + "relative_path": "lib/lean/Init/Data/Array/Basic.olean", + "sha256": "c1b3ecb3200b55fd9c0f508d6a70518cad1e6cd68e3333d6363ac275efa290b4" + }, + "Init.Data.Array.BasicAux": { + "relative_path": "lib/lean/Init/Data/Array/BasicAux.olean", + "sha256": "498f1b5994a45cd4303c9a5a1252d20f1706d7227fd6068a54a21102c4ecb49d" + }, + "Init.Data.Array.BinSearch": { + "relative_path": "lib/lean/Init/Data/Array/BinSearch.olean", + "sha256": "c8ffd80ccccd8119ba40ef890a3408310abd6535ecb282e8ecd8f8b943dad63a" + }, + "Init.Data.Array.Bootstrap": { + "relative_path": "lib/lean/Init/Data/Array/Bootstrap.olean", + "sha256": "d22a9ec6e5a01f844321cfd7ecfba9f02f0d15cffd6e7667315e36caaf2f4d5d" + }, + "Init.Data.Array.Count": { + "relative_path": "lib/lean/Init/Data/Array/Count.olean", + "sha256": "5cac2d9caf60f31946dcc2b3ecacde3f52d6c143dd91504af2245e9203360700" + }, + "Init.Data.Array.DecidableEq": { + "relative_path": "lib/lean/Init/Data/Array/DecidableEq.olean", + "sha256": "61699c7b47f0fe3ceabab22f86fad529d0c53c229168e2eb5a4c81b3b44161da" + }, + "Init.Data.Array.Erase": { + "relative_path": "lib/lean/Init/Data/Array/Erase.olean", + "sha256": "a39e0a7704569c26626a57596aa4838b835eb5940a90874febcd53aed46c3676" + }, + "Init.Data.Array.Extract": { + "relative_path": "lib/lean/Init/Data/Array/Extract.olean", + "sha256": "d3ae74a38b69aaf4e3f7cf247e3b51d97845035076f21c37f9516f17dec53115" + }, + "Init.Data.Array.FinRange": { + "relative_path": "lib/lean/Init/Data/Array/FinRange.olean", + "sha256": "ccdba2d4e97ed32f04ea6d66ffa24cd4667d3c17e923939d251b12b8c156ff0a" + }, + "Init.Data.Array.Find": { + "relative_path": "lib/lean/Init/Data/Array/Find.olean", + "sha256": "60374792eaf3e1c935911342aadc2e0fe2c2df226d1b2ffeead456d396242565" + }, + "Init.Data.Array.GetLit": { + "relative_path": "lib/lean/Init/Data/Array/GetLit.olean", + "sha256": "7500dfd2f61932caa3bb61dff522cea1d043f9d52f875df9ca9377cb5be6ae00" + }, + "Init.Data.Array.InsertIdx": { + "relative_path": "lib/lean/Init/Data/Array/InsertIdx.olean", + "sha256": "0885128103fece2609d3de7d95170ead99c2422e3b2611efc17ad64d13c54b93" + }, + "Init.Data.Array.InsertionSort": { + "relative_path": "lib/lean/Init/Data/Array/InsertionSort.olean", + "sha256": "00eeffee6c9c944e626b54aa1ba80e2817ee0d6d72a58b4504ed5d6150963199" + }, + "Init.Data.Array.Lemmas": { + "relative_path": "lib/lean/Init/Data/Array/Lemmas.olean", + "sha256": "6d70a718a88e0f5e3a2fbf58ab9a927086ecb80cc131ca4daf61b8373b29bc7e" + }, + "Init.Data.Array.Lex": { + "relative_path": "lib/lean/Init/Data/Array/Lex.olean", + "sha256": "dcfcf549b75b61784fc2761dd6ab27112a5f3f85635156ff45f17907241f873c" + }, + "Init.Data.Array.Lex.Basic": { + "relative_path": "lib/lean/Init/Data/Array/Lex/Basic.olean", + "sha256": "5099ffc811762f879efd0a8d2dc6a6f46b03aaf13e5d7198a40b028f84339f6a" + }, + "Init.Data.Array.Lex.Lemmas": { + "relative_path": "lib/lean/Init/Data/Array/Lex/Lemmas.olean", + "sha256": "edd3b29355f8877ba1d4baa7eb7191d19ec56b68e8caf7136e56562d46f2cf00" + }, + "Init.Data.Array.MapIdx": { + "relative_path": "lib/lean/Init/Data/Array/MapIdx.olean", + "sha256": "fa5fa7562d940a373cde8271701c1b1b6aa4ccc7685a7d8aee563bd6a531b023" + }, + "Init.Data.Array.Mem": { + "relative_path": "lib/lean/Init/Data/Array/Mem.olean", + "sha256": "6d8b81e87c3f6194010d50453930aef26a33d02836f577fdf528f96427fd2871" + }, + "Init.Data.Array.Monadic": { + "relative_path": "lib/lean/Init/Data/Array/Monadic.olean", + "sha256": "4c7ac2031c6b67e8904e378eab4f4e4e52a741464f759346c6bbadf358353040" + }, + "Init.Data.Array.OfFn": { + "relative_path": "lib/lean/Init/Data/Array/OfFn.olean", + "sha256": "269214e9ef1869f764ea7744d27f9bb5f2d88c06a199c35a523bcab485056514" + }, + "Init.Data.Array.Perm": { + "relative_path": "lib/lean/Init/Data/Array/Perm.olean", + "sha256": "df04ccb43fffbdfc14af5e01b9a288eba07cf33dfd934fefc7d3ee62380abbad" + }, + "Init.Data.Array.QSort": { + "relative_path": "lib/lean/Init/Data/Array/QSort.olean", + "sha256": "182e2fb5ccae0e4290f1df223f6da4fe8e4671735b1f8be5768f67aecd976a9b" + }, + "Init.Data.Array.Range": { + "relative_path": "lib/lean/Init/Data/Array/Range.olean", + "sha256": "470d0a04ec3f6acf4e1a4a17c0ac006ff4f4ca6a132e6fe75cb24a3422045edf" + }, + "Init.Data.Array.Set": { + "relative_path": "lib/lean/Init/Data/Array/Set.olean", + "sha256": "47765fffb2b0ff3eeb3b9fcdf1f872a1264fbecc6fd9fa3b3bcacb14305d21cc" + }, + "Init.Data.Array.Subarray": { + "relative_path": "lib/lean/Init/Data/Array/Subarray.olean", + "sha256": "a2b4eb8e9ff8708540ec1224bc150ec997f6b339fc526c8f905824dab5814eb1" + }, + "Init.Data.Array.Subarray.Split": { + "relative_path": "lib/lean/Init/Data/Array/Subarray/Split.olean", + "sha256": "e70f52b7a240f6f48ece84e6e5efe81be6f0aa59787d93877069acf4d299d6da" + }, + "Init.Data.Array.TakeDrop": { + "relative_path": "lib/lean/Init/Data/Array/TakeDrop.olean", + "sha256": "cb756a88720cd6633a931cc4cd278804391f1d4b6e7804fed40e0014f27250e4" + }, + "Init.Data.Array.Zip": { + "relative_path": "lib/lean/Init/Data/Array/Zip.olean", + "sha256": "57b72c19de8fc1a600d24da0a2ce3edc78620fc487668928f5092c62e6199bf8" + }, + "Init.Data.BEq": { + "relative_path": "lib/lean/Init/Data/BEq.olean", + "sha256": "fc264bbc09afcdee4cf301170287f97dce8426a1102c2c20a2b3324af470be03" + }, + "Init.Data.Basic": { + "relative_path": "lib/lean/Init/Data/Basic.olean", + "sha256": "320b6a318c7f47b88b4cc52a3dd10f1c253c4ba15882c0fba4d0b6cc8b258629" + }, + "Init.Data.BitVec": { + "relative_path": "lib/lean/Init/Data/BitVec.olean", + "sha256": "9806987569400445640812d3675deb3d56b79c12d42e8168aebba2d2d42ef3cd" + }, + "Init.Data.BitVec.Basic": { + "relative_path": "lib/lean/Init/Data/BitVec/Basic.olean", + "sha256": "263c59d8eecd1dca7acf46649c80ce9d7b5680064309b9eedc76d4ca02a03e34" + }, + "Init.Data.BitVec.BasicAux": { + "relative_path": "lib/lean/Init/Data/BitVec/BasicAux.olean", + "sha256": "1ba7804f2a9d1739a51b1e7dea3821a38743373b1072bf85c41d247cfa8bcbaa" + }, + "Init.Data.BitVec.Bitblast": { + "relative_path": "lib/lean/Init/Data/BitVec/Bitblast.olean", + "sha256": "c7663248b6910786438135f4eabd9f5fce7ddb61628c667345d04c4be6dda7b3" + }, + "Init.Data.BitVec.Folds": { + "relative_path": "lib/lean/Init/Data/BitVec/Folds.olean", + "sha256": "b4d4aa0cfd3f346fd1f6361552afcf5245668c55fd2d0ad1ebf467f841ae20d0" + }, + "Init.Data.BitVec.Lemmas": { + "relative_path": "lib/lean/Init/Data/BitVec/Lemmas.olean", + "sha256": "c11aebc16adf6f6fdd8d3a9dcb74b295034999579793c2f4eb79b044fccd618e" + }, + "Init.Data.Bool": { + "relative_path": "lib/lean/Init/Data/Bool.olean", + "sha256": "24c3fa2ac49e5f1681100130790a5f322bed745e47b503e25ff49b7a3c5f6d68" + }, + "Init.Data.ByteArray": { + "relative_path": "lib/lean/Init/Data/ByteArray.olean", + "sha256": "3c0fa93b6b78ea8b3733b02a83dca06a085b3938355811eee6c06cbdd0179a8e" + }, + "Init.Data.ByteArray.Basic": { + "relative_path": "lib/lean/Init/Data/ByteArray/Basic.olean", + "sha256": "f995de7efe27dc6573bf9cf32e2399ba4ee0659f0b64f07285bb15edbd8048fd" + }, + "Init.Data.Cast": { + "relative_path": "lib/lean/Init/Data/Cast.olean", + "sha256": "3413b2ca8a0098a6e572d7728ed1532eaa21ca10067197f3b214aeff2ccdd651" + }, + "Init.Data.Channel": { + "relative_path": "lib/lean/Init/Data/Channel.olean", + "sha256": "945114f1dd771f97d93cdac7466ff0ff1e0f1461bc4fda27b5f5b9715dcdc174" + }, + "Init.Data.Char": { + "relative_path": "lib/lean/Init/Data/Char.olean", + "sha256": "818aac23581c282c3f6d2f80775ac47ce6d31b55ce54b3d187b6ed4b8de8cc63" + }, + "Init.Data.Char.Basic": { + "relative_path": "lib/lean/Init/Data/Char/Basic.olean", + "sha256": "6ed0988e9f8e134dbc30d38ed257a44850e98d71b7d77d5a977f4297e085a0f1" + }, + "Init.Data.Char.Lemmas": { + "relative_path": "lib/lean/Init/Data/Char/Lemmas.olean", + "sha256": "030a6cdcb16360b9f90d072e40bd66ce8aafab43137dd9d03e82229ebec3ced9" + }, + "Init.Data.Fin": { + "relative_path": "lib/lean/Init/Data/Fin.olean", + "sha256": "e955ad0ee4c253aaf23086b1452740c2c9888c594b9c404bb34699868773dfe2" + }, + "Init.Data.Fin.Basic": { + "relative_path": "lib/lean/Init/Data/Fin/Basic.olean", + "sha256": "e4b2abb6d8a424da6e7ff21b0e71ead051c0605e76db3680888305ac128f5b55" + }, + "Init.Data.Fin.Bitwise": { + "relative_path": "lib/lean/Init/Data/Fin/Bitwise.olean", + "sha256": "e80029b17e55e5e4b917ef076545aa017bb7844bed24f7f3c376952d82f3e21b" + }, + "Init.Data.Fin.Fold": { + "relative_path": "lib/lean/Init/Data/Fin/Fold.olean", + "sha256": "8d618def1ed982a59898c72e714939d861836ea9f84fe4414677c4b7fac9295a" + }, + "Init.Data.Fin.Iterate": { + "relative_path": "lib/lean/Init/Data/Fin/Iterate.olean", + "sha256": "f6553fbf009244d2b848079f104ef424f9048ad5e5e45276169f58b674dbdf58" + }, + "Init.Data.Fin.Lemmas": { + "relative_path": "lib/lean/Init/Data/Fin/Lemmas.olean", + "sha256": "9fe597ce2f3edce6a67a4542d72bd0300cc643a484297fc8d61966a28b61935d" + }, + "Init.Data.Fin.Log2": { + "relative_path": "lib/lean/Init/Data/Fin/Log2.olean", + "sha256": "d4e9f3e05222a066c5fdc327065d7147d16a939ebcedf988b8e428bfd7a1d6a3" + }, + "Init.Data.Float": { + "relative_path": "lib/lean/Init/Data/Float.olean", + "sha256": "92478058b9b83eddef7ecea3797414d74db6e61e2b688e64ab7ba81df127b15a" + }, + "Init.Data.Float32": { + "relative_path": "lib/lean/Init/Data/Float32.olean", + "sha256": "2a37e1add33b9d6047350feaa9d87b913f1e58718bd5a3cb597d60e6573f9212" + }, + "Init.Data.FloatArray": { + "relative_path": "lib/lean/Init/Data/FloatArray.olean", + "sha256": "78c9b7500ea433aede3b8587af3bbbe727c8ebfd6f8a5942f6c0d14b0faa44b5" + }, + "Init.Data.FloatArray.Basic": { + "relative_path": "lib/lean/Init/Data/FloatArray/Basic.olean", + "sha256": "7169a26af51b7faaa9712ed85d9423a43b5c4f31ba4ccdbb3289eeaaf58e0afa" + }, + "Init.Data.Format": { + "relative_path": "lib/lean/Init/Data/Format.olean", + "sha256": "82528100ce60ae1eded58f45a0319b76ac7c80f9d834c60bec31cddd2a1f836b" + }, + "Init.Data.Format.Basic": { + "relative_path": "lib/lean/Init/Data/Format/Basic.olean", + "sha256": "7b7e7500d7a86ce98f996e4c6045c7fff49ee0efc72737cfc5ab4c284ad77f4a" + }, + "Init.Data.Format.Instances": { + "relative_path": "lib/lean/Init/Data/Format/Instances.olean", + "sha256": "b8bede2673426df8591cc8d2837854e12fd82f83132adcdb5d4fa6492b9f1d21" + }, + "Init.Data.Format.Macro": { + "relative_path": "lib/lean/Init/Data/Format/Macro.olean", + "sha256": "d4b42a5cd357e4c35a328183571bb8a919d2dba0e0241b081293c449b726ae35" + }, + "Init.Data.Format.Syntax": { + "relative_path": "lib/lean/Init/Data/Format/Syntax.olean", + "sha256": "3433640ca9aeb5ef96fda95bf9dc747d0feba236f3a3db2860f92970c5718882" + }, + "Init.Data.Function": { + "relative_path": "lib/lean/Init/Data/Function.olean", + "sha256": "17fa8cf9a33f44e97d1a3a8c77e086c567ef0520291421839b77b28fdbd2b8fa" + }, + "Init.Data.Hashable": { + "relative_path": "lib/lean/Init/Data/Hashable.olean", + "sha256": "0d9ba8712572cf7103ef0e4c1012f4c3d1b10bbc3f9d55409eb315ed87f26e7f" + }, + "Init.Data.Int": { + "relative_path": "lib/lean/Init/Data/Int.olean", + "sha256": "4628002a234694983f14e288745898d889aada1b0d9d9fbff5f3fb8dbb72c20a" + }, + "Init.Data.Int.Basic": { + "relative_path": "lib/lean/Init/Data/Int/Basic.olean", + "sha256": "926f11cf3beb5d66e06dc405f6aac7f39b38c440ba23baa26827ca79724b8eae" + }, + "Init.Data.Int.Bitwise": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise.olean", + "sha256": "527f601e3b6565c4e13a78e71c252c99f51b0203fba8e9a48bf61a6d702f7f77" + }, + "Init.Data.Int.Bitwise.Basic": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise/Basic.olean", + "sha256": "265104afaeebfc4163d1f1ab6bc8913ec7def48a6e0cf7c33a619e7c6b7996cd" + }, + "Init.Data.Int.Bitwise.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/Bitwise/Lemmas.olean", + "sha256": "61fdbf3f93888946c2c76b36a1ac73246abd87048eb30a596d009a0dddfe3af0" + }, + "Init.Data.Int.Cooper": { + "relative_path": "lib/lean/Init/Data/Int/Cooper.olean", + "sha256": "607b77466cb24c6ae2b99b1bd054709dd7e315d0019d87854e45e588d2f4f061" + }, + "Init.Data.Int.DivMod": { + "relative_path": "lib/lean/Init/Data/Int/DivMod.olean", + "sha256": "0ac18881bb522630e818a1f973051dd26d51a7edfe6589132274694575627416" + }, + "Init.Data.Int.DivMod.Basic": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Basic.olean", + "sha256": "1bf5aad5de1a3d6931194060a4fe8fa304dced06404dd2815057179beecb7945" + }, + "Init.Data.Int.DivMod.Bootstrap": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Bootstrap.olean", + "sha256": "9f5e940c4fba88142e73ea864aee5257a1bf31566d3d67d1ebdd60967230d2c5" + }, + "Init.Data.Int.DivMod.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/DivMod/Lemmas.olean", + "sha256": "dbb9ae219e1f2072be3ed6986c5f713b1df79f563fab946fc903c7bcfdce7f48" + }, + "Init.Data.Int.Gcd": { + "relative_path": "lib/lean/Init/Data/Int/Gcd.olean", + "sha256": "294b7f9b1144098337d3b1eae9a286741c2a503388078bd601cf03bbc74e5af8" + }, + "Init.Data.Int.Lemmas": { + "relative_path": "lib/lean/Init/Data/Int/Lemmas.olean", + "sha256": "e447675a36f3fa775915d9c711e4172eb1575cb80d4f631ea9b4a0cf7319d791" + }, + "Init.Data.Int.LemmasAux": { + "relative_path": "lib/lean/Init/Data/Int/LemmasAux.olean", + "sha256": "f58eaab4a411b1dd8b2505d7b5479dc203c603ea9ee4a28dfc2e37ac6a1c50d3" + }, + "Init.Data.Int.Linear": { + "relative_path": "lib/lean/Init/Data/Int/Linear.olean", + "sha256": "a6f99acdf60bcb9b582ef87f01c9d53a76e61ea6466a7f4a9d5e4d5c9f564bc8" + }, + "Init.Data.Int.OfNat": { + "relative_path": "lib/lean/Init/Data/Int/OfNat.olean", + "sha256": "8b91634fcd25ef8639461730e11a2e30d7c0f479bd7c86064f1dbb0edf05d47c" + }, + "Init.Data.Int.Order": { + "relative_path": "lib/lean/Init/Data/Int/Order.olean", + "sha256": "32e716ca6845ff6b54befdb1d6fa157e6980471455c22c7c34a5fa1b206c5aaf" + }, + "Init.Data.Int.Pow": { + "relative_path": "lib/lean/Init/Data/Int/Pow.olean", + "sha256": "916584050412a63f5e067a8d86818a2576cd971f241d2bcce80da6ad9d2cebcd" + }, + "Init.Data.List": { + "relative_path": "lib/lean/Init/Data/List.olean", + "sha256": "a0b4ba4434de3cbe61e2009557a6b2c237e7ed24d903486b02efc2460594ebbe" + }, + "Init.Data.List.Attach": { + "relative_path": "lib/lean/Init/Data/List/Attach.olean", + "sha256": "1b460daad56a1203c465d63575d1fd1b0c417c9b22daa53d1239d3e3cf8858e3" + }, + "Init.Data.List.Basic": { + "relative_path": "lib/lean/Init/Data/List/Basic.olean", + "sha256": "45f40cdc05ba064b67aff84c6957f82c4a2e6edd0052fa508cc749e9d35999e1" + }, + "Init.Data.List.BasicAux": { + "relative_path": "lib/lean/Init/Data/List/BasicAux.olean", + "sha256": "210a850a3c6f96fb462b42a67920eed86b41cdfafd32adb39a272d4f66ab09fe" + }, + "Init.Data.List.Control": { + "relative_path": "lib/lean/Init/Data/List/Control.olean", + "sha256": "b082dae0a9caf27e9ebecc9d183598e091016f323b6b1c30942bfe9ac14915b6" + }, + "Init.Data.List.Count": { + "relative_path": "lib/lean/Init/Data/List/Count.olean", + "sha256": "37e1a1a86c77f09c1ae6f13af53e9f0fbc8dd888485e1796b1c0b2813904811a" + }, + "Init.Data.List.Erase": { + "relative_path": "lib/lean/Init/Data/List/Erase.olean", + "sha256": "2ff3cc2f53a947bba4110106d48bd8e6a746fbdbccda3d3168988377f9bf08d6" + }, + "Init.Data.List.FinRange": { + "relative_path": "lib/lean/Init/Data/List/FinRange.olean", + "sha256": "174b84f766bfad55861d5f9bf45051d705e4762491232c25589eda8491aee1fb" + }, + "Init.Data.List.Find": { + "relative_path": "lib/lean/Init/Data/List/Find.olean", + "sha256": "10dabc67b4e589018d889930fc75a663a75d91c7f083095e5892c3e359019d1d" + }, + "Init.Data.List.Impl": { + "relative_path": "lib/lean/Init/Data/List/Impl.olean", + "sha256": "1e62f8c4f057317bb61e73e76f39cbd3b699c7a45c168ab405f7c2cf35c3d2fe" + }, + "Init.Data.List.Lemmas": { + "relative_path": "lib/lean/Init/Data/List/Lemmas.olean", + "sha256": "ebcbcfb4dfc92e4eb9ece72b6c538b4809f96585313aef48cc91ed3e386f2ecc" + }, + "Init.Data.List.Lex": { + "relative_path": "lib/lean/Init/Data/List/Lex.olean", + "sha256": "3b9fb1bdab57ade29c2834da21d90ae802ccf7e58899b17ff487f6483c56ec72" + }, + "Init.Data.List.MapIdx": { + "relative_path": "lib/lean/Init/Data/List/MapIdx.olean", + "sha256": "bd024799a195c348a5937950048fddade6c7cc32ca43abc8e93a0d77c9593f3c" + }, + "Init.Data.List.MinMax": { + "relative_path": "lib/lean/Init/Data/List/MinMax.olean", + "sha256": "1fc6795971ac8f3530113326fb3e351626a4146db9c4772152b2ffe4a3bb81e1" + }, + "Init.Data.List.Monadic": { + "relative_path": "lib/lean/Init/Data/List/Monadic.olean", + "sha256": "82900949d78e7fc5b7c6415194cba03b2526409b350a39f923a78d9911132448" + }, + "Init.Data.List.Nat": { + "relative_path": "lib/lean/Init/Data/List/Nat.olean", + "sha256": "7963464ebb33af6223be0712ffb5bbe47c4587ae5380a61cbc5c6021baf9b422" + }, + "Init.Data.List.Nat.BEq": { + "relative_path": "lib/lean/Init/Data/List/Nat/BEq.olean", + "sha256": "fa52c59704dd8e1822d4b0257d670aedbb2f82017b74303bf358af42d494a450" + }, + "Init.Data.List.Nat.Basic": { + "relative_path": "lib/lean/Init/Data/List/Nat/Basic.olean", + "sha256": "745ae4e831f8597a5165d4dc9abc953c280a450a6547963f109c0fc18cbd6746" + }, + "Init.Data.List.Nat.Count": { + "relative_path": "lib/lean/Init/Data/List/Nat/Count.olean", + "sha256": "73ccebc5a9a303a8a9f2c9137d3fb60c3191b4d74c40370e53dc15e781536493" + }, + "Init.Data.List.Nat.Erase": { + "relative_path": "lib/lean/Init/Data/List/Nat/Erase.olean", + "sha256": "b8d0f4703d71d05efc7c94d8d2c2bad1278f1c65302ce0ee11275e93857f3b3c" + }, + "Init.Data.List.Nat.Find": { + "relative_path": "lib/lean/Init/Data/List/Nat/Find.olean", + "sha256": "73d6e91b894c9907bdb3a7087fa1fcc174fe4a96aac39055a797b84b8ec5f26a" + }, + "Init.Data.List.Nat.InsertIdx": { + "relative_path": "lib/lean/Init/Data/List/Nat/InsertIdx.olean", + "sha256": "5c5ac7ada578ca3a04908c1c6b94e2f12e684da28a3534fd8e2fb1712ba06a38" + }, + "Init.Data.List.Nat.Modify": { + "relative_path": "lib/lean/Init/Data/List/Nat/Modify.olean", + "sha256": "275e5291a6691082786680f93b2e0d09710e0fbcd9640b6503bbbf35041756aa" + }, + "Init.Data.List.Nat.Pairwise": { + "relative_path": "lib/lean/Init/Data/List/Nat/Pairwise.olean", + "sha256": "8aae1be95bb7c08d8e20bde2bdc46d737a4c54c6c132fb093782603e11f88e36" + }, + "Init.Data.List.Nat.Perm": { + "relative_path": "lib/lean/Init/Data/List/Nat/Perm.olean", + "sha256": "d34b546b7057199bf2b89b45908696cdc173bcbb8ff6e14c20e8553fce164014" + }, + "Init.Data.List.Nat.Range": { + "relative_path": "lib/lean/Init/Data/List/Nat/Range.olean", + "sha256": "56804bb0f398b27aba960edeff1d44703f3d59c67c72f540b9e4016fe7e005a3" + }, + "Init.Data.List.Nat.Sublist": { + "relative_path": "lib/lean/Init/Data/List/Nat/Sublist.olean", + "sha256": "cb179f24812905731bee16e0aabbf5eda0d6e1a07d693a0297798e3fab4316ab" + }, + "Init.Data.List.Nat.TakeDrop": { + "relative_path": "lib/lean/Init/Data/List/Nat/TakeDrop.olean", + "sha256": "86594d76cd6bca152ceabb5eaf14e7d2843b484cc2ae20233bf70eca4db3d470" + }, + "Init.Data.List.Notation": { + "relative_path": "lib/lean/Init/Data/List/Notation.olean", + "sha256": "231f63a53a24060f593b32f6321d2e5f1159bdb57172f5fd3e9ca2c38f137733" + }, + "Init.Data.List.OfFn": { + "relative_path": "lib/lean/Init/Data/List/OfFn.olean", + "sha256": "4d4a1feaf8df21b7567908a2723e0cd0bbb9ab1568a9cf1e6536c08a177c1119" + }, + "Init.Data.List.Pairwise": { + "relative_path": "lib/lean/Init/Data/List/Pairwise.olean", + "sha256": "6a00f9b67bb5554815fb9ca404ddf0f7df1fcb0c53d9b40a7de569f752a70779" + }, + "Init.Data.List.Perm": { + "relative_path": "lib/lean/Init/Data/List/Perm.olean", + "sha256": "16c720de1fc7adedfc438ed72845cdc53267779413765172a77e4540662d1a10" + }, + "Init.Data.List.Range": { + "relative_path": "lib/lean/Init/Data/List/Range.olean", + "sha256": "646ca36cfb7cb2359c5589af542f7b1714018cd2c2e06e705f38e8e69515ef29" + }, + "Init.Data.List.Sort": { + "relative_path": "lib/lean/Init/Data/List/Sort.olean", + "sha256": "c2718b7978559839c5c4493fa3a8efec0f89b75ba052319781ff102e2d4f874a" + }, + "Init.Data.List.Sort.Basic": { + "relative_path": "lib/lean/Init/Data/List/Sort/Basic.olean", + "sha256": "2358d6d69b08c0a229dd3fdc38598e300f65e534ac1a3db61495d2c68440b783" + }, + "Init.Data.List.Sort.Impl": { + "relative_path": "lib/lean/Init/Data/List/Sort/Impl.olean", + "sha256": "663f7c421f200455d1b5f73bbb1bc7698a83258cc2b8dd36d537f016f9eb9a77" + }, + "Init.Data.List.Sort.Lemmas": { + "relative_path": "lib/lean/Init/Data/List/Sort/Lemmas.olean", + "sha256": "8c31e71b3777de0363ff903a15fb77da2b64ca6e2a6df7e0f169c6fa6c68b9fc" + }, + "Init.Data.List.Sublist": { + "relative_path": "lib/lean/Init/Data/List/Sublist.olean", + "sha256": "626fc37b3fccd3ad01e524e497bed2e7470f69025ffb5c96477c5dda33cf93b8" + }, + "Init.Data.List.TakeDrop": { + "relative_path": "lib/lean/Init/Data/List/TakeDrop.olean", + "sha256": "6ad55d35f8158e3093612d2bd82b2fcc6e0e2692b89276374fbad91d05316236" + }, + "Init.Data.List.ToArray": { + "relative_path": "lib/lean/Init/Data/List/ToArray.olean", + "sha256": "d48db070507418071d7f3294285e8fd02ded1fe084445b6a728476fa0e5ef34b" + }, + "Init.Data.List.ToArrayImpl": { + "relative_path": "lib/lean/Init/Data/List/ToArrayImpl.olean", + "sha256": "877b70f91eb55124127734da7195914515b98abc3d601053119e4d10b3c749bf" + }, + "Init.Data.List.Zip": { + "relative_path": "lib/lean/Init/Data/List/Zip.olean", + "sha256": "b3ec8eed3d680c246fefdb0e57293acd2c2257a085937f2d1e026d118f6d3979" + }, + "Init.Data.Nat": { + "relative_path": "lib/lean/Init/Data/Nat.olean", + "sha256": "3447a7734bddbbc6904f5135e848dbca25c10bc5b6fad83b1beb09ac5bdb1fae" + }, + "Init.Data.Nat.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Basic.olean", + "sha256": "b2d11a9c4afa558c793fa12d41da087604ee0cf5dd8ee4f3c2f0b08e90031a50" + }, + "Init.Data.Nat.Bitwise": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise.olean", + "sha256": "ec84e12fb7c621de1fe2a6d0cf393bdec0b211e0741b6b343130d09417e0adc9" + }, + "Init.Data.Nat.Bitwise.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise/Basic.olean", + "sha256": "8f01e5e6af6b3366171fb8f21ba8a336c0ddef11a2a180b0fc033ef53757a69a" + }, + "Init.Data.Nat.Bitwise.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Bitwise/Lemmas.olean", + "sha256": "844179c496ff2ff5233abfec08e333e04170dd8b49a43f98ae15be7539b83b4b" + }, + "Init.Data.Nat.Compare": { + "relative_path": "lib/lean/Init/Data/Nat/Compare.olean", + "sha256": "9ce920efa06d6fb5e143925d07dd673e488640a5fc56c8c814ef41f383a0b6aa" + }, + "Init.Data.Nat.Control": { + "relative_path": "lib/lean/Init/Data/Nat/Control.olean", + "sha256": "126864791c444a3025fb8be008a42e792773f82535cb1fe9c80b6a9b0cbb0783" + }, + "Init.Data.Nat.Div.Basic": { + "relative_path": "lib/lean/Init/Data/Nat/Div/Basic.olean", + "sha256": "90ace86481881951b8aac0c78b829052894c5168bb81b4e32c48daefe634259e" + }, + "Init.Data.Nat.Div.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Div/Lemmas.olean", + "sha256": "06a8a626caa61480fa596adfa0fe6230b4b84cdbbf4f049da8a744dffa25efbc" + }, + "Init.Data.Nat.Dvd": { + "relative_path": "lib/lean/Init/Data/Nat/Dvd.olean", + "sha256": "36f58914fb3acef3f1b99aae4e1024647886c96f3575cd2cdb7b90e48b63a62f" + }, + "Init.Data.Nat.Fold": { + "relative_path": "lib/lean/Init/Data/Nat/Fold.olean", + "sha256": "ccbbc29df5d8b98e47f6d1ee36aa3cb036aa61c3adad7945bd72ef22117ecf0a" + }, + "Init.Data.Nat.Gcd": { + "relative_path": "lib/lean/Init/Data/Nat/Gcd.olean", + "sha256": "746fe45b4e8c648caebc10c1ba9e2736ebd492bb4854edc96c8d5c0f10905666" + }, + "Init.Data.Nat.Lcm": { + "relative_path": "lib/lean/Init/Data/Nat/Lcm.olean", + "sha256": "bbb02321b1e2b2422adf0d8c10b3800afe668a9edbb434e3dbd83c45386539de" + }, + "Init.Data.Nat.Lemmas": { + "relative_path": "lib/lean/Init/Data/Nat/Lemmas.olean", + "sha256": "7acb7e4f1b14d45188f28aa341f9013ee1c6bba8f0e1c2f3be74e04dd24b4782" + }, + "Init.Data.Nat.Linear": { + "relative_path": "lib/lean/Init/Data/Nat/Linear.olean", + "sha256": "33b034e32879e503ae843a62df9969d47e341eddf2650e299209e1494e507c2c" + }, + "Init.Data.Nat.Log2": { + "relative_path": "lib/lean/Init/Data/Nat/Log2.olean", + "sha256": "a1147619414a0561c2e404ca16b6f9c1b3e764fd66917d26964ff53d6f33d10b" + }, + "Init.Data.Nat.MinMax": { + "relative_path": "lib/lean/Init/Data/Nat/MinMax.olean", + "sha256": "813cd65d09f92a707754d8d86d35ae396b2ac77953076e7444021250799546dc" + }, + "Init.Data.Nat.Mod": { + "relative_path": "lib/lean/Init/Data/Nat/Mod.olean", + "sha256": "232fa20934aab58dfc025430ba91fe814d90e0e67f979a401fc91ea8a0fd06e3" + }, + "Init.Data.Nat.Power2": { + "relative_path": "lib/lean/Init/Data/Nat/Power2.olean", + "sha256": "aa68d47f1481ea940e4f2f3eeb5eb0cf44d9d36a81f02609f834bce92b36144a" + }, + "Init.Data.Nat.SOM": { + "relative_path": "lib/lean/Init/Data/Nat/SOM.olean", + "sha256": "be398ccbd96728c1500ab66aa2063131d37d6acd214067dbe14fb3a61150ff4d" + }, + "Init.Data.Nat.Simproc": { + "relative_path": "lib/lean/Init/Data/Nat/Simproc.olean", + "sha256": "491fdb35ea98fc6d352b6cb46c3681d42cb9e23f2df42a07a8e764b54ef7a62b" + }, + "Init.Data.NeZero": { + "relative_path": "lib/lean/Init/Data/NeZero.olean", + "sha256": "5fcec208f2769e4ec00ebf7dc0b534ffba76859d7390bac0ba36da69c8d06d0d" + }, + "Init.Data.OfScientific": { + "relative_path": "lib/lean/Init/Data/OfScientific.olean", + "sha256": "5a86fb094fc122609b959999bc53159282db03b2aba36b1d564270c95b630cc7" + }, + "Init.Data.Option": { + "relative_path": "lib/lean/Init/Data/Option.olean", + "sha256": "7cec7ba7cbb4f8c12b723822ef37fa80d7fe6dad55ffe781b04d480f37bee3e9" + }, + "Init.Data.Option.Attach": { + "relative_path": "lib/lean/Init/Data/Option/Attach.olean", + "sha256": "d13d8661e92455466e2652e81b0fc20660c6f68f61563e06ff9ada3b2adef85e" + }, + "Init.Data.Option.Basic": { + "relative_path": "lib/lean/Init/Data/Option/Basic.olean", + "sha256": "8a83ae7602811f2a8caa2f5ec890dfcaad71b7fee193f45329f23ce538838eae" + }, + "Init.Data.Option.BasicAux": { + "relative_path": "lib/lean/Init/Data/Option/BasicAux.olean", + "sha256": "69c9769a227956d0a18263f65759b2c78eeca5fc23df52fada29fae941be58b8" + }, + "Init.Data.Option.Instances": { + "relative_path": "lib/lean/Init/Data/Option/Instances.olean", + "sha256": "c2af58842fc1a5ace3156d8cc201a287eb79ad7707be50f11d43d9f6096452b8" + }, + "Init.Data.Option.Lemmas": { + "relative_path": "lib/lean/Init/Data/Option/Lemmas.olean", + "sha256": "832a8d1633685e7ace5ceb52ee44b1f441548ff85b6f15687314cc3709b9138e" + }, + "Init.Data.Option.List": { + "relative_path": "lib/lean/Init/Data/Option/List.olean", + "sha256": "919cbd303c6345f52d6c019146d46b4249daf12fe9fd3c2cfbece14797be8393" + }, + "Init.Data.Option.Monadic": { + "relative_path": "lib/lean/Init/Data/Option/Monadic.olean", + "sha256": "6f76327d567c5dbf041689c11ff396fdebbc832a1640d003ad2020671282aeb1" + }, + "Init.Data.Ord": { + "relative_path": "lib/lean/Init/Data/Ord.olean", + "sha256": "f9c47b462803dd4e251e3c89acc944998c255728461d0b038aa239e067c81a9c" + }, + "Init.Data.PLift": { + "relative_path": "lib/lean/Init/Data/PLift.olean", + "sha256": "2bed69175449aa3166dc103d9cf368e494b4d1752ed6e864250214256d710739" + }, + "Init.Data.Prod": { + "relative_path": "lib/lean/Init/Data/Prod.olean", + "sha256": "0498bf822d3922cd5bbc154bf0adef4fd76e4fe6a57f8e39fefa49ae9e16ca13" + }, + "Init.Data.Queue": { + "relative_path": "lib/lean/Init/Data/Queue.olean", + "sha256": "ab5118c07c9c0ed7d0819d19d442d1e6143f265f784f48151be1c4e2cd895606" + }, + "Init.Data.RArray": { + "relative_path": "lib/lean/Init/Data/RArray.olean", + "sha256": "9abe7370b3817a85b8512bc51dadc386f314bdcec188736b2f87405d5a9bb09b" + }, + "Init.Data.Random": { + "relative_path": "lib/lean/Init/Data/Random.olean", + "sha256": "5a34ed96d6a9814781db7e6c93847b8cd7caeb7071b2256058964866ec706af5" + }, + "Init.Data.Range": { + "relative_path": "lib/lean/Init/Data/Range.olean", + "sha256": "c64640dc9f5f61844778a90d7acc0f8f632ec11aa1746689c960d0f459bfaf46" + }, + "Init.Data.Range.Basic": { + "relative_path": "lib/lean/Init/Data/Range/Basic.olean", + "sha256": "bf692fd52dbffb6518f9a189179263fc4c49b436dbdb9eba2f00940de6665353" + }, + "Init.Data.Range.Lemmas": { + "relative_path": "lib/lean/Init/Data/Range/Lemmas.olean", + "sha256": "19e241eb048d7046e42e9117499d5bc8a43dddf66dacbb087966b4d16b82b06b" + }, + "Init.Data.Repr": { + "relative_path": "lib/lean/Init/Data/Repr.olean", + "sha256": "cbbd2014d6cee442d42c9c4d6997aa1e27dd3a4ea4fef43d1de4c1f184d02138" + }, + "Init.Data.SInt": { + "relative_path": "lib/lean/Init/Data/SInt.olean", + "sha256": "21f02e1e015c8ceee0e8afe9a24f8150714739a4df724b922e7b3f3756cc530d" + }, + "Init.Data.SInt.Basic": { + "relative_path": "lib/lean/Init/Data/SInt/Basic.olean", + "sha256": "c4b9b22f462ffe3dac0f5ce0d810e9cbbd3dda83a3c8f61aaca350f99edf30d9" + }, + "Init.Data.SInt.Bitwise": { + "relative_path": "lib/lean/Init/Data/SInt/Bitwise.olean", + "sha256": "784166152e7e37d32e49f556007eb9e8ac78a11e25a33159256124b1b6ac78b9" + }, + "Init.Data.SInt.Float": { + "relative_path": "lib/lean/Init/Data/SInt/Float.olean", + "sha256": "0fa2df58fc374f7d8f8381dc7369e0359fd56854418863015d82b50a49032bdd" + }, + "Init.Data.SInt.Float32": { + "relative_path": "lib/lean/Init/Data/SInt/Float32.olean", + "sha256": "08b0e06d73a8cc4989ef19e5b5dc0255aa458e852dade1660aeee88046199fb6" + }, + "Init.Data.SInt.Lemmas": { + "relative_path": "lib/lean/Init/Data/SInt/Lemmas.olean", + "sha256": "14f5714b32a97f7b89fe4f737e96d2d9576a75fdbdf62b848c26140b1be0d0b9" + }, + "Init.Data.Stream": { + "relative_path": "lib/lean/Init/Data/Stream.olean", + "sha256": "df7b2b39a4577fbe33f63d916ef4e0592fea0db8bc542b7e3f65bf8fca137950" + }, + "Init.Data.String": { + "relative_path": "lib/lean/Init/Data/String.olean", + "sha256": "44d46641afe72049132e8ba521b7e404190fb50b1710a008a531a6cb4bce4308" + }, + "Init.Data.String.Basic": { + "relative_path": "lib/lean/Init/Data/String/Basic.olean", + "sha256": "d7404ec9c0cedeb3e77cc7eadc3201e7cf1d44e1029407a279ce5dd2ab5537d1" + }, + "Init.Data.String.Extra": { + "relative_path": "lib/lean/Init/Data/String/Extra.olean", + "sha256": "5291234dedeae61b8f31129e9e8d90fcc2b91a784384250d36eea11c694e359a" + }, + "Init.Data.String.Lemmas": { + "relative_path": "lib/lean/Init/Data/String/Lemmas.olean", + "sha256": "e2fa260513d3ccaba3d0547bc5625ebbe09a171762e375b38b6dc1b8dc0fa6f5" + }, + "Init.Data.Subtype": { + "relative_path": "lib/lean/Init/Data/Subtype.olean", + "sha256": "1278a669b084dabde55a3f9a14c8b3ea7b7753b4b4d52bdbc1066bcb29f30208" + }, + "Init.Data.Sum": { + "relative_path": "lib/lean/Init/Data/Sum.olean", + "sha256": "0c08e5312a75c9474abf94ce7f6358efbdc6c178476005e36c22b5b294647930" + }, + "Init.Data.Sum.Basic": { + "relative_path": "lib/lean/Init/Data/Sum/Basic.olean", + "sha256": "30b5a85e6941f567feb412f1e6a4382d5c6d52558c4657285e80bd1b58879427" + }, + "Init.Data.Sum.Lemmas": { + "relative_path": "lib/lean/Init/Data/Sum/Lemmas.olean", + "sha256": "01ce321477e3f24f07aca5b0c4423c46d4c4e9533f25e00cdfd3f7e0af9ba319" + }, + "Init.Data.ToString": { + "relative_path": "lib/lean/Init/Data/ToString.olean", + "sha256": "bf141c2b4f750f8154aff447a05b8c02fc0231c48e550bf29823dd3a101b60a6" + }, + "Init.Data.ToString.Basic": { + "relative_path": "lib/lean/Init/Data/ToString/Basic.olean", + "sha256": "0892126af7fd71f9dd48a1f051af4f1ca5f181389a9b97dd7c759abcb8088fd0" + }, + "Init.Data.ToString.Macro": { + "relative_path": "lib/lean/Init/Data/ToString/Macro.olean", + "sha256": "3284b8ed0d3883ba46d39abb4d3620820bf6f12e47bfe3f33ead82ad80039580" + }, + "Init.Data.UInt": { + "relative_path": "lib/lean/Init/Data/UInt.olean", + "sha256": "a92781a10cb664f3b9dc344957d3c5c95bf9ec44fbe192cbb6ceac4c1d9f1391" + }, + "Init.Data.UInt.Basic": { + "relative_path": "lib/lean/Init/Data/UInt/Basic.olean", + "sha256": "d30c2c0bff573487362546d06fe7cf8fc0ae6dfead1379a1ad2523fc96795eb9" + }, + "Init.Data.UInt.BasicAux": { + "relative_path": "lib/lean/Init/Data/UInt/BasicAux.olean", + "sha256": "76e27df77fe31ef1d6b54d00a1758d579532a15787f4cfec7da774d535b47072" + }, + "Init.Data.UInt.Bitwise": { + "relative_path": "lib/lean/Init/Data/UInt/Bitwise.olean", + "sha256": "aa829cd7c8a6e68d0365d1662727646fc68b817428e469b33d96d057f6643d4e" + }, + "Init.Data.UInt.Lemmas": { + "relative_path": "lib/lean/Init/Data/UInt/Lemmas.olean", + "sha256": "5912f89a17ba6b111d9d7f3df46904b90811a4cdd80fc02a06984cd4c3dd3aa0" + }, + "Init.Data.UInt.Log2": { + "relative_path": "lib/lean/Init/Data/UInt/Log2.olean", + "sha256": "315c374ceeecdab0fde8042abffb68b082f063ce3ebf810efa46d89eb239faca" + }, + "Init.Data.ULift": { + "relative_path": "lib/lean/Init/Data/ULift.olean", + "sha256": "e1187f01e60437dc3c741cd1ba76657855642cc2574a59fa9a3be9a9e9d435b4" + }, + "Init.Data.Vector": { + "relative_path": "lib/lean/Init/Data/Vector.olean", + "sha256": "8ff79e5ffafceccc1bc38f3ac3d5ae7eb802c95cf1bd51393c6af7be6dfdea63" + }, + "Init.Data.Vector.Attach": { + "relative_path": "lib/lean/Init/Data/Vector/Attach.olean", + "sha256": "ecf089f945d2adcc57180f779593ccf0a2fa0c27d89968a7722b914f4b58b8af" + }, + "Init.Data.Vector.Basic": { + "relative_path": "lib/lean/Init/Data/Vector/Basic.olean", + "sha256": "afacc92812490337d7f03950905748563477bfe6494f046a0dfd9451aa4a4d65" + }, + "Init.Data.Vector.Count": { + "relative_path": "lib/lean/Init/Data/Vector/Count.olean", + "sha256": "b23fa70c6a9f0ea3b8ed1a4c811a2d0557751d4bb798e954d1ff985e00d492b1" + }, + "Init.Data.Vector.DecidableEq": { + "relative_path": "lib/lean/Init/Data/Vector/DecidableEq.olean", + "sha256": "4cf94f33d63c842c39f35392ce1bbf4c40ed1bfe9ec5161d522ba1442d8e0a2c" + }, + "Init.Data.Vector.Erase": { + "relative_path": "lib/lean/Init/Data/Vector/Erase.olean", + "sha256": "8c5cf30ba1225d74d85f93b3553f09e9299c182805f0efb44fad509ea5e56b78" + }, + "Init.Data.Vector.Extract": { + "relative_path": "lib/lean/Init/Data/Vector/Extract.olean", + "sha256": "0e12201859d76ac91415a74e00f909b32a631fefd2d2b5d7afeb0d2730bfa47a" + }, + "Init.Data.Vector.FinRange": { + "relative_path": "lib/lean/Init/Data/Vector/FinRange.olean", + "sha256": "b862166a52500e392a3cfab1b4b4f5d2b7b202725f48526a1e935ca52abdda38" + }, + "Init.Data.Vector.InsertIdx": { + "relative_path": "lib/lean/Init/Data/Vector/InsertIdx.olean", + "sha256": "c3f496caa69211325d18bc909f9be134bfd07515f8b95773b252004a71e01fc5" + }, + "Init.Data.Vector.Lemmas": { + "relative_path": "lib/lean/Init/Data/Vector/Lemmas.olean", + "sha256": "35726f2c825e29355e25d574a25470dba908ea9f680b92f4e6ab57ec77d47f3d" + }, + "Init.Data.Vector.Lex": { + "relative_path": "lib/lean/Init/Data/Vector/Lex.olean", + "sha256": "1541eb5302ac1fe618815bd36a3d4468f08003a6571118fc8322bbf155b441de" + }, + "Init.Data.Vector.MapIdx": { + "relative_path": "lib/lean/Init/Data/Vector/MapIdx.olean", + "sha256": "cbe812bbd7839fae0178d0c183d96d1f29f768b55349bebb47628f903c7cda57" + }, + "Init.Data.Vector.Monadic": { + "relative_path": "lib/lean/Init/Data/Vector/Monadic.olean", + "sha256": "c44bb39a17f785673f64d6e40116173d821d9184c41377371c5cb73565440a30" + }, + "Init.Data.Vector.OfFn": { + "relative_path": "lib/lean/Init/Data/Vector/OfFn.olean", + "sha256": "69f88342bdd241ebafeffb51ee94c1363ab096ea6d435ef4d062b1a552167cf4" + }, + "Init.Data.Vector.Range": { + "relative_path": "lib/lean/Init/Data/Vector/Range.olean", + "sha256": "88351024a2b10fd4648a0ae15e005d8799b95be7d0060c89a5a205a4fc40b56f" + }, + "Init.Data.Vector.Zip": { + "relative_path": "lib/lean/Init/Data/Vector/Zip.olean", + "sha256": "8c28067d8d5289ec3a5cbc9674643c688210c75813c69c0b66baba5ea29abaea" + }, + "Init.Data.Zero": { + "relative_path": "lib/lean/Init/Data/Zero.olean", + "sha256": "04d070309e7a1962ebcb5de2b2bfa69e5f5d4d54477689cbdbadb21202611dac" + }, + "Init.Dynamic": { + "relative_path": "lib/lean/Init/Dynamic.olean", + "sha256": "a9982d28dff48820a4e5310d473b53d19de91c1d1685749bccb849e881219fa1" + }, + "Init.Ext": { + "relative_path": "lib/lean/Init/Ext.olean", + "sha256": "1f32591106d111c224423e61d0afd89014b96aa77e9141c6bec47b33b80c31f7" + }, + "Init.GetElem": { + "relative_path": "lib/lean/Init/GetElem.olean", + "sha256": "2683b27cced90b5fbfbe5213c309ed94bf423edf90924a1002eea72b152fdb58" + }, + "Init.Grind": { + "relative_path": "lib/lean/Init/Grind.olean", + "sha256": "33eff60d5cea8bd5db12879a12cf1a1cf772b1a2ab778136cc138685bc23654a" + }, + "Init.Grind.Cases": { + "relative_path": "lib/lean/Init/Grind/Cases.olean", + "sha256": "d086d84578922287a95fedee2f43e884a629e838c2ff8e71efc2910510509594" + }, + "Init.Grind.Lemmas": { + "relative_path": "lib/lean/Init/Grind/Lemmas.olean", + "sha256": "ca22a5c6a54190290fc558e7805244c66c3c044c3a708a98300703d70bef11ec" + }, + "Init.Grind.Norm": { + "relative_path": "lib/lean/Init/Grind/Norm.olean", + "sha256": "3f889971f8415ffff0f737c2214d5be92be1294398624aec1c9d9bd45942dd66" + }, + "Init.Grind.Offset": { + "relative_path": "lib/lean/Init/Grind/Offset.olean", + "sha256": "4f95e7282b636fe3690d8b159425a37bf5bb2f80c49e7ccdd6170b6977148d50" + }, + "Init.Grind.PP": { + "relative_path": "lib/lean/Init/Grind/PP.olean", + "sha256": "d94c99691443ce7517096899dc89ffd3a1eff62b621e530ff98e46ff7a9e4407" + }, + "Init.Grind.Propagator": { + "relative_path": "lib/lean/Init/Grind/Propagator.olean", + "sha256": "e292ef4b9a9a4475f7c6eb767ddc84d8b5f0a30feabbbb1664966930e050496f" + }, + "Init.Grind.Tactics": { + "relative_path": "lib/lean/Init/Grind/Tactics.olean", + "sha256": "8c21109288355c0969f3fae78c66756b2a73699d4170d53336d0825a82b2b82d" + }, + "Init.Grind.Util": { + "relative_path": "lib/lean/Init/Grind/Util.olean", + "sha256": "666cf848a9a3ba30885be219a767d96bd2b6582fde19f84110c3c583308c5e8f" + }, + "Init.Guard": { + "relative_path": "lib/lean/Init/Guard.olean", + "sha256": "3bec2e0ab8c2829d1d13c64c80fb983b5d5f115a67b29ee64eedbe3f6628a470" + }, + "Init.Hints": { + "relative_path": "lib/lean/Init/Hints.olean", + "sha256": "5c814650ff2f23259cc67c04ab1a438222ec084d4369aca679fd0cc07cbb5474" + }, + "Init.Internal": { + "relative_path": "lib/lean/Init/Internal.olean", + "sha256": "2927550a155fb6115ac63e31cc35f9969047a6c015ced8325ce769d5631c0200" + }, + "Init.Internal.Order": { + "relative_path": "lib/lean/Init/Internal/Order.olean", + "sha256": "37884830614f3f48f325497beadc3cc60f0e363a1846cdcc28221ca05ba39759" + }, + "Init.Internal.Order.Basic": { + "relative_path": "lib/lean/Init/Internal/Order/Basic.olean", + "sha256": "c0b362116c8f553cc59964154fdc9a3418672bf9b5caee2b745608f40aa71091" + }, + "Init.Internal.Order.Lemmas": { + "relative_path": "lib/lean/Init/Internal/Order/Lemmas.olean", + "sha256": "198fb9d38168f2116937d641fa5419c99e0e9c03c0f630756f68affca451c1e0" + }, + "Init.Internal.Order.Tactic": { + "relative_path": "lib/lean/Init/Internal/Order/Tactic.olean", + "sha256": "d519c1d64b866e639de30ef452587bbe8802c64536e6ee541e47fcc7be3f942d" + }, + "Init.MacroTrace": { + "relative_path": "lib/lean/Init/MacroTrace.olean", + "sha256": "49d356d5728ea1a0ed6a14cbca10b6387f99d40b85602189566c4e4c1d6cc524" + }, + "Init.Meta": { + "relative_path": "lib/lean/Init/Meta.olean", + "sha256": "16b7ad338addb717e0eb584fc583a2e9d4e08242040654a2d3546650cb71bddc" + }, + "Init.MetaTypes": { + "relative_path": "lib/lean/Init/MetaTypes.olean", + "sha256": "1aa89a88743c9d8f66daecc6f28a7a7816efad55a42129bca1e2220450747bd8" + }, + "Init.Notation": { + "relative_path": "lib/lean/Init/Notation.olean", + "sha256": "576706b70dc9f21b093c7b10755e25c2f3fea8f04586b128893308730d715dae" + }, + "Init.NotationExtra": { + "relative_path": "lib/lean/Init/NotationExtra.olean", + "sha256": "92ba272c0a25c97e7800cdf2e948bb20e374861d28d31736d80a757b7dd852b0" + }, + "Init.Omega": { + "relative_path": "lib/lean/Init/Omega.olean", + "sha256": "ef46ae7141263a8f3168ddc0de5b10c37cd991f907e6558d6a10daed027950ad" + }, + "Init.Omega.Coeffs": { + "relative_path": "lib/lean/Init/Omega/Coeffs.olean", + "sha256": "a7f2688fb1799c93744fb62301026c37c58ee81d58eb91e80041622397bd1dd3" + }, + "Init.Omega.Constraint": { + "relative_path": "lib/lean/Init/Omega/Constraint.olean", + "sha256": "1e5a89907d661084e3223c006975f275efbe03df7c43fd18a68425798ac09189" + }, + "Init.Omega.Int": { + "relative_path": "lib/lean/Init/Omega/Int.olean", + "sha256": "335df595a7449bc9ab310b9a5914bcae3ad6219121cd1f67261deb8383b5d61d" + }, + "Init.Omega.IntList": { + "relative_path": "lib/lean/Init/Omega/IntList.olean", + "sha256": "315f3755c1bdb87eda3449e97cb3141b9bc69b88af3faa93b0c54a5bf16137bf" + }, + "Init.Omega.LinearCombo": { + "relative_path": "lib/lean/Init/Omega/LinearCombo.olean", + "sha256": "6f254b2ed1ea5d35519b633f58da229500dca18293b3d958c7f93cc6a7e64e67" + }, + "Init.Omega.Logic": { + "relative_path": "lib/lean/Init/Omega/Logic.olean", + "sha256": "c8b7e60bd2aeee6efbab4f4787a5eddcb8b6ccb02841b7948b5120b5dbc7f5be" + }, + "Init.Prelude": { + "relative_path": "lib/lean/Init/Prelude.olean", + "sha256": "db4e87c0006f1303f3d41ca9a615a4890ca94309812bda09476677ea9bb5d672" + }, + "Init.PropLemmas": { + "relative_path": "lib/lean/Init/PropLemmas.olean", + "sha256": "f95cab4646f43dbaca3fc915bbd32868f0ac73aaeba818d165843e276499542e" + }, + "Init.RCases": { + "relative_path": "lib/lean/Init/RCases.olean", + "sha256": "aa216281d8930fe16cdb7b6b1f604066e824b33eaf62870d41391040c2ba77b4" + }, + "Init.ShareCommon": { + "relative_path": "lib/lean/Init/ShareCommon.olean", + "sha256": "c2647e2778a9bf01ffdc302ea5604308036ee982de23feac85ce21805f0b3ba8" + }, + "Init.SimpLemmas": { + "relative_path": "lib/lean/Init/SimpLemmas.olean", + "sha256": "37b58f69317f08a8e55d1f3950c4d00ccb29ebed135eb5e9789e8feb4f412369" + }, + "Init.Simproc": { + "relative_path": "lib/lean/Init/Simproc.olean", + "sha256": "53b36872b429c61141ac340011f233e680f82ccced2fb43fabf9fbeca5807040" + }, + "Init.SizeOf": { + "relative_path": "lib/lean/Init/SizeOf.olean", + "sha256": "0b2e2a18d9b699a5236c79acca835fd68f5400bbd998ca5743825c5734b6d589" + }, + "Init.SizeOfLemmas": { + "relative_path": "lib/lean/Init/SizeOfLemmas.olean", + "sha256": "ef5ba22b92506575f987eaea9cb87eda5a1d870da071e53f1257cb1cc999fd85" + }, + "Init.Syntax": { + "relative_path": "lib/lean/Init/Syntax.olean", + "sha256": "55eab3582563a12c40c7797ed6d06db613c855508c3138df975d2613422f6399" + }, + "Init.System": { + "relative_path": "lib/lean/Init/System.olean", + "sha256": "7a0e2f92d28211ac4da2835c7b15db71b08799d68e0c759c0f899b7c19ef564c" + }, + "Init.System.FilePath": { + "relative_path": "lib/lean/Init/System/FilePath.olean", + "sha256": "cdc4f4ecf0cd8470047e8c1e706d22f7321bee3072e44a669481e56689e187f1" + }, + "Init.System.IO": { + "relative_path": "lib/lean/Init/System/IO.olean", + "sha256": "069217c5d17f79433867ec6f701a5702cb40c88485dedc61be1f1ce0ef9b44fb" + }, + "Init.System.IOError": { + "relative_path": "lib/lean/Init/System/IOError.olean", + "sha256": "6e1ff344b12e6d7fcbb7abea99eaa3c88ae2626dd669d7f3c545822f96494ec2" + }, + "Init.System.Mutex": { + "relative_path": "lib/lean/Init/System/Mutex.olean", + "sha256": "fc950b4b00a1c3104ea945a9a93ab51807521b29a0b83518127de77eb3f76922" + }, + "Init.System.Platform": { + "relative_path": "lib/lean/Init/System/Platform.olean", + "sha256": "b679564c6df441632b6277f089cd588220ae5c4b8ae519873dc3172bb3091e52" + }, + "Init.System.Promise": { + "relative_path": "lib/lean/Init/System/Promise.olean", + "sha256": "78dc6c800d0f873e6520dbcf32c9dda22370563c75f086fb03e25fae393e848c" + }, + "Init.System.ST": { + "relative_path": "lib/lean/Init/System/ST.olean", + "sha256": "3fc620f17a5cb9e2243d760ffcb7ede9227b8c639c9376ff25c6bea1a7c1a7e7" + }, + "Init.System.Uri": { + "relative_path": "lib/lean/Init/System/Uri.olean", + "sha256": "d1a020ceeb21e6358fb0768345f90866752ef2dfe6c9dec71f388bd34b919de3" + }, + "Init.Tactics": { + "relative_path": "lib/lean/Init/Tactics.olean", + "sha256": "285e86e84ef77045b1f4944cacef6f11bca49334671808adec30f2e6fafd0dd8" + }, + "Init.TacticsExtra": { + "relative_path": "lib/lean/Init/TacticsExtra.olean", + "sha256": "e0521889dab4e1a74e8a407a0a0409109723ab9363b4be234115dc80aa01b5ba" + }, + "Init.Task": { + "relative_path": "lib/lean/Init/Task.olean", + "sha256": "effc51f55f006a6e54f0bb4b6577f7fe6a92d79958a0f3dfd258e4c53b9fa3c8" + }, + "Init.Try": { + "relative_path": "lib/lean/Init/Try.olean", + "sha256": "d289104c53a554fd4e7d8b81d5fd8212dcca854e6dec5cf80e088e3545a23c6b" + }, + "Init.Util": { + "relative_path": "lib/lean/Init/Util.olean", + "sha256": "da825c487c1ff3bf957f8ef84fade6ca10e2428807f84f52613551e11a404f03" + }, + "Init.WF": { + "relative_path": "lib/lean/Init/WF.olean", + "sha256": "16d58f1a3442679940e0f5d0eb9fd209e6eae04f7f4550dd7361847f0ba97082" + }, + "Init.WFTactics": { + "relative_path": "lib/lean/Init/WFTactics.olean", + "sha256": "edeb5134b3fc1f3234ef027a4d803b733c75a7174ac2a4bfe8a6353f783deb32" + }, + "Init.While": { + "relative_path": "lib/lean/Init/While.olean", + "sha256": "6fc8fbe7c581376a6826126ce6aacb031231cdc32afb135dfa3bfda884305625" + }, + "Lean": { + "relative_path": "lib/lean/Lean.olean", + "sha256": "7b09317fc9d21262dbfbb6f014dc40c2809b55e6cbb4f7587211a57ec91f7221" + }, + "Lean.AddDecl": { + "relative_path": "lib/lean/Lean/AddDecl.olean", + "sha256": "ec30e087524b32520021eeb3dc8c2d0aefdce838f11dd8e57f13cf1f05611cf8" + }, + "Lean.Attributes": { + "relative_path": "lib/lean/Lean/Attributes.olean", + "sha256": "e4db4a704b0260d6e36f4f542416091124e09767dc8bc759d2b1adbe53e9c166" + }, + "Lean.AuxRecursor": { + "relative_path": "lib/lean/Lean/AuxRecursor.olean", + "sha256": "8ad6ecf040763b62561819bb75de71763765566d01e68d3ed60fe27ff1b70b92" + }, + "Lean.BuiltinDocAttr": { + "relative_path": "lib/lean/Lean/BuiltinDocAttr.olean", + "sha256": "c9fb01241ff340cc8cdba6efffa553449f24748d42f0966903ce7b3038a6f266" + }, + "Lean.Class": { + "relative_path": "lib/lean/Lean/Class.olean", + "sha256": "0a41587a7d43178adb832ac6a835a3ded745f5b94f031b8a7fa916a6de2d681c" + }, + "Lean.Compiler": { + "relative_path": "lib/lean/Lean/Compiler.olean", + "sha256": "60a1e6cb63d9ee93f449d816b9d5f35d550da07c2ed98d4574cc00610aaa1fcc" + }, + "Lean.Compiler.AtMostOnce": { + "relative_path": "lib/lean/Lean/Compiler/AtMostOnce.olean", + "sha256": "46d86c6dc85f433a42dfa3a3162ed82530e0efd6d0def6857c447342776280b5" + }, + "Lean.Compiler.BorrowedAnnotation": { + "relative_path": "lib/lean/Lean/Compiler/BorrowedAnnotation.olean", + "sha256": "dfd99a6b65e28ce3c81d6effb32273e088fcce5829cbaeec57a98a4f325c70a8" + }, + "Lean.Compiler.CSimpAttr": { + "relative_path": "lib/lean/Lean/Compiler/CSimpAttr.olean", + "sha256": "4228ef18768f8fd70d1c48c5a5e9c7e0736e84389e0cc291d45ea6ef55853c85" + }, + "Lean.Compiler.ClosedTermCache": { + "relative_path": "lib/lean/Lean/Compiler/ClosedTermCache.olean", + "sha256": "332d9fcc102a8ec05d9d450f835de662c8b153274e86f4e8f8bf72bb7c0c86fa" + }, + "Lean.Compiler.ConstFolding": { + "relative_path": "lib/lean/Lean/Compiler/ConstFolding.olean", + "sha256": "a0f0396a65891075ef27848bf3578a2b14c5d9fa295ee982014d97cae25ec46c" + }, + "Lean.Compiler.ExportAttr": { + "relative_path": "lib/lean/Lean/Compiler/ExportAttr.olean", + "sha256": "f0975b5550d69d83ad3b27d0ad2363641167e47178788f22890be83d3e5511e6" + }, + "Lean.Compiler.ExternAttr": { + "relative_path": "lib/lean/Lean/Compiler/ExternAttr.olean", + "sha256": "c015f64d0e192ec7b6774ea02f82e8d210aa29022cc9317ba1f44f4d1db03983" + }, + "Lean.Compiler.FFI": { + "relative_path": "lib/lean/Lean/Compiler/FFI.olean", + "sha256": "5c592270389ca3547b225d542569d17074a72aab1d3069972aa13183c9defb4b" + }, + "Lean.Compiler.IR": { + "relative_path": "lib/lean/Lean/Compiler/IR.olean", + "sha256": "c0d443734bf92a204df7d44fb5b213073d860465d1940beb4f56be04fe95fa5d" + }, + "Lean.Compiler.IR.Basic": { + "relative_path": "lib/lean/Lean/Compiler/IR/Basic.olean", + "sha256": "256c663d51575e663739cf47717d5b563d91bccd233443d8c71ff95eb81ccf2b" + }, + "Lean.Compiler.IR.Borrow": { + "relative_path": "lib/lean/Lean/Compiler/IR/Borrow.olean", + "sha256": "76ccf72d60d34df08de11583942e4978c88f79daea6c48a34aee9b0b0164a143" + }, + "Lean.Compiler.IR.Boxing": { + "relative_path": "lib/lean/Lean/Compiler/IR/Boxing.olean", + "sha256": "ba56d60339b940f7b1d5f1bc244145dd90c835bd7a7c22501af7ab4eb502c7e9" + }, + "Lean.Compiler.IR.Checker": { + "relative_path": "lib/lean/Lean/Compiler/IR/Checker.olean", + "sha256": "0760b0f827e3f94462f855b0cde1e99a4f2ececa4dc914bb36ccc7388d05ea1f" + }, + "Lean.Compiler.IR.CompilerM": { + "relative_path": "lib/lean/Lean/Compiler/IR/CompilerM.olean", + "sha256": "3c51c9bc8b5684d2b997424a46ecfffd0faebaeccc20871faa6142bbdee6261e" + }, + "Lean.Compiler.IR.CtorLayout": { + "relative_path": "lib/lean/Lean/Compiler/IR/CtorLayout.olean", + "sha256": "41b6538779aec55878034a4311f5ec5afb609ee355306207f63d480beec7d8f1" + }, + "Lean.Compiler.IR.ElimDeadBranches": { + "relative_path": "lib/lean/Lean/Compiler/IR/ElimDeadBranches.olean", + "sha256": "db8b2361ec98aeab4251a3f24b6bdd6dfea6560736a7e2db580ac80ea5a19088" + }, + "Lean.Compiler.IR.ElimDeadVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/ElimDeadVars.olean", + "sha256": "fa545c9536767b2921812ec4f12787dbafdb12fba219c37c50ef08406aed35c0" + }, + "Lean.Compiler.IR.EmitC": { + "relative_path": "lib/lean/Lean/Compiler/IR/EmitC.olean", + "sha256": "8d3cc7f7314b0540efc952a891d2c04b146a0e974c78698f257aa84218e22fa8" + }, + "Lean.Compiler.IR.EmitUtil": { + "relative_path": "lib/lean/Lean/Compiler/IR/EmitUtil.olean", + "sha256": "d94b654927d21d70638e7be9f071d042f1ddef03ffb35c8e1873ce06f6bc0bec" + }, + "Lean.Compiler.IR.ExpandResetReuse": { + "relative_path": "lib/lean/Lean/Compiler/IR/ExpandResetReuse.olean", + "sha256": "52056b452d80b3cc358d961c340c878bd8fd439c4157f19579ab24b6e45beb63" + }, + "Lean.Compiler.IR.Format": { + "relative_path": "lib/lean/Lean/Compiler/IR/Format.olean", + "sha256": "7ce035303406e57cca579f9730815aae11392a6b068ebfb1ae5563989ef9d648" + }, + "Lean.Compiler.IR.FreeVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/FreeVars.olean", + "sha256": "b7689c40b2b8acb573130f0678e945f7de1f93cc0d2cc516992b735d3b16600c" + }, + "Lean.Compiler.IR.LiveVars": { + "relative_path": "lib/lean/Lean/Compiler/IR/LiveVars.olean", + "sha256": "04dffa3befd0baf2b1caabada126812e8799e0842e88ae55d2f9f435b210bba7" + }, + "Lean.Compiler.IR.NormIds": { + "relative_path": "lib/lean/Lean/Compiler/IR/NormIds.olean", + "sha256": "42d1c0c091dd6795dc22f817e1bbd69f8a023744028d476ee73c3d47b9094507" + }, + "Lean.Compiler.IR.PushProj": { + "relative_path": "lib/lean/Lean/Compiler/IR/PushProj.olean", + "sha256": "45d3a0ef752e7ec5a2868af25c01793a0e9763307b35d8821fb1aeeb0886e5e7" + }, + "Lean.Compiler.IR.RC": { + "relative_path": "lib/lean/Lean/Compiler/IR/RC.olean", + "sha256": "efe9f4218bc3bc9ff1df43dbd6d5d5629c6914bc69834a1642f67aa16b9c7a1c" + }, + "Lean.Compiler.IR.ResetReuse": { + "relative_path": "lib/lean/Lean/Compiler/IR/ResetReuse.olean", + "sha256": "efe1a6814901274604fe1e6ada5e6819c56a50ade0732c255a5fabbac86b90f0" + }, + "Lean.Compiler.IR.SimpCase": { + "relative_path": "lib/lean/Lean/Compiler/IR/SimpCase.olean", + "sha256": "3c29f2a2fc5a04a44b6afa8c945055dc63aaee07fa17412c49f32b66b93af17b" + }, + "Lean.Compiler.IR.Sorry": { + "relative_path": "lib/lean/Lean/Compiler/IR/Sorry.olean", + "sha256": "4f931aed57566e1db5097e0703d072434871fcfad52bedd7afefda28c9e28b49" + }, + "Lean.Compiler.IR.UnboxResult": { + "relative_path": "lib/lean/Lean/Compiler/IR/UnboxResult.olean", + "sha256": "7a27c69a4b077ee78cd5c060dab56b7af05e02428073627d28ccdff330e74670" + }, + "Lean.Compiler.ImplementedByAttr": { + "relative_path": "lib/lean/Lean/Compiler/ImplementedByAttr.olean", + "sha256": "0bdd1c11d87a3e766eb8372e72dbdc72606b0367551455d1ff3093d50a14ba0e" + }, + "Lean.Compiler.InitAttr": { + "relative_path": "lib/lean/Lean/Compiler/InitAttr.olean", + "sha256": "a4b773a972dd41b77fa8973f7c570e3c2f1eef2a56e36c6b5b91a9543fe23efd" + }, + "Lean.Compiler.InlineAttrs": { + "relative_path": "lib/lean/Lean/Compiler/InlineAttrs.olean", + "sha256": "1dc521edbac6c28fb0abe0b1bfa72372d225b00d184228cb135fea3b3900583c" + }, + "Lean.Compiler.LCNF": { + "relative_path": "lib/lean/Lean/Compiler/LCNF.olean", + "sha256": "50ba85811e79db199dcc8528997fe62c599b3e36bae0bff0c56da744a975815e" + }, + "Lean.Compiler.LCNF.AlphaEqv": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/AlphaEqv.olean", + "sha256": "3e525daf1858d10b3c576598392a797f9bc77af47c88877a81f4b80f95e39f60" + }, + "Lean.Compiler.LCNF.AuxDeclCache": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/AuxDeclCache.olean", + "sha256": "e4ebfeac04cc04ab322e324c6b5cceb5fb0049899d323ace2185ed1d82f20460" + }, + "Lean.Compiler.LCNF.BaseTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/BaseTypes.olean", + "sha256": "5053822e35b6065475c75ea4121fb7c0e5572473b589a6318c23d8245cb91031" + }, + "Lean.Compiler.LCNF.Basic": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Basic.olean", + "sha256": "61a9c336f3fc892426f33ce054488c33e6c853038561acc10f6e68f1c4dae86f" + }, + "Lean.Compiler.LCNF.Bind": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Bind.olean", + "sha256": "ddcb0976ae13b967a67b86197dd84df7911382cfc311cc72f1643bcde382170e" + }, + "Lean.Compiler.LCNF.CSE": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CSE.olean", + "sha256": "0f30cf963d74e913c63d6a61eb2e6024a51aae3598e1bb7d67fe68e2571983b1" + }, + "Lean.Compiler.LCNF.Check": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Check.olean", + "sha256": "bfa8071c59de426aaa04e96c0c7cc9adabcba58266af88e878efc333efa217cc" + }, + "Lean.Compiler.LCNF.Closure": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Closure.olean", + "sha256": "8e07eaf84941feda5b4549dcbbfa53cd0981cf41053d3cb7604de6b37055b89c" + }, + "Lean.Compiler.LCNF.CompatibleTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CompatibleTypes.olean", + "sha256": "bbbd5d8598de30d40edc079da53afced3be253be5f5bc1ba5098b673a39178a7" + }, + "Lean.Compiler.LCNF.CompilerM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/CompilerM.olean", + "sha256": "0dba55f8281250c8f7c8ca16d327e9c699a12bc22b7a740cc4494c9807071148" + }, + "Lean.Compiler.LCNF.ConfigOptions": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ConfigOptions.olean", + "sha256": "911b57609345802250709851c15ca20bb8b0c72d7cd38eb43691c09523cec4a7" + }, + "Lean.Compiler.LCNF.DeclHash": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/DeclHash.olean", + "sha256": "5e269b1f1ac7904fb9ebb77fe9805065fbb378fecf06eef5f123dc27a84b8555" + }, + "Lean.Compiler.LCNF.DependsOn": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/DependsOn.olean", + "sha256": "e7d096fac73063f27b1fc6f49c0eb5c4b7edb7075115cae9f2635e894fc7b070" + }, + "Lean.Compiler.LCNF.ElimDead": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ElimDead.olean", + "sha256": "477333313db8979680b9ee364d3075b5162225b83a69c60f18afca99f5f184c9" + }, + "Lean.Compiler.LCNF.ElimDeadBranches": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ElimDeadBranches.olean", + "sha256": "67ca5f89e780bfa7c0e62c0318b038421385dd3d9165ee207e2ba55a8edc3b50" + }, + "Lean.Compiler.LCNF.FVarUtil": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FVarUtil.olean", + "sha256": "d15ee92fbc441d2a5805f9fd5f851c49dd7267fc259d058273771168ce44b2b4" + }, + "Lean.Compiler.LCNF.FixedParams": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FixedParams.olean", + "sha256": "02e113791b21bc00471cc5e650e0167187e9b60993dc1627c1a0591cf9e928dc" + }, + "Lean.Compiler.LCNF.FloatLetIn": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/FloatLetIn.olean", + "sha256": "aa1a425efb344b0216c4d87f584165e314acc54702788de99d359010f51cd5ef" + }, + "Lean.Compiler.LCNF.InferType": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/InferType.olean", + "sha256": "b91d6fbb425074a2e8296fbc557159c22b409e8f2ffa2dcf554f17d8d40f43fc" + }, + "Lean.Compiler.LCNF.Internalize": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Internalize.olean", + "sha256": "ddf26e1a280b6fcf208f46ca6683ffe8ef366527c447557a8852ba581abab6ff" + }, + "Lean.Compiler.LCNF.JoinPoints": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/JoinPoints.olean", + "sha256": "7955fd7fbf4caccbfc179059f5821358b5155dcce356bf20dbc5465989d12831" + }, + "Lean.Compiler.LCNF.LCtx": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/LCtx.olean", + "sha256": "798958fc2fdf1ff92063e6a5696a66dd32273a5eb6e04bfb217759105882742a" + }, + "Lean.Compiler.LCNF.LambdaLifting": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/LambdaLifting.olean", + "sha256": "16f7b519cd8548d6a88aff2c02029440110f13b2b009fb26afa4e8018d76f106" + }, + "Lean.Compiler.LCNF.Level": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Level.olean", + "sha256": "0ff39a4eec80e3c8047e926f4843c44eea5c1516e24c059c1c941d0948df7a6b" + }, + "Lean.Compiler.LCNF.Main": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Main.olean", + "sha256": "3678ef37331fb5a8b609a8ebfae188c589e87fef79ffff24533ea4059160f40c" + }, + "Lean.Compiler.LCNF.MonadScope": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/MonadScope.olean", + "sha256": "b16649d04910e51525f2513891c35417ccc791a9d19331355aea31cdbbe72a2e" + }, + "Lean.Compiler.LCNF.MonoTypes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/MonoTypes.olean", + "sha256": "6135eec86d64970beb3d9b00a2b74b30c0401784884cde565eefe186f42c7dac" + }, + "Lean.Compiler.LCNF.OtherDecl": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/OtherDecl.olean", + "sha256": "3cd7c6d125c8127901949761c55b36ebc963b7f28047fbb67221f978b966d0d0" + }, + "Lean.Compiler.LCNF.PassManager": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PassManager.olean", + "sha256": "0e7573909dd4940a95abface78fa3660072b1c6163a859562aec0e48c85451cf" + }, + "Lean.Compiler.LCNF.Passes": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Passes.olean", + "sha256": "4b8864ccdfb3dabe28940e0e21f1726c3bbb252371c38e7992852f7da95ad0c9" + }, + "Lean.Compiler.LCNF.PhaseExt": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PhaseExt.olean", + "sha256": "8ed93f368be15928b930d48136cac9cac5eb283d269b53a4ccf9dc915480564c" + }, + "Lean.Compiler.LCNF.PrettyPrinter": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PrettyPrinter.olean", + "sha256": "484d0ba585c4943205d33a53df8d4735f52e7b4c65f9cc39a2dadece7e3ee769" + }, + "Lean.Compiler.LCNF.PullFunDecls": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PullFunDecls.olean", + "sha256": "20c18b55f55cc4cf61b95e3be8c6e2c2c1ce63af493e30d543534faf53550bc7" + }, + "Lean.Compiler.LCNF.PullLetDecls": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/PullLetDecls.olean", + "sha256": "848f051bce9b922816355c97fc84232a03f85ed5fa38feed1b12ec6ff07eacac" + }, + "Lean.Compiler.LCNF.ReduceArity": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ReduceArity.olean", + "sha256": "bfb8fba4b4cf6829d092a9f3f4b5807108f7110296e6a9f71ceeb1f6ec90cd43" + }, + "Lean.Compiler.LCNF.ReduceJpArity": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ReduceJpArity.olean", + "sha256": "9bb32eeb3214ac55e1013ad425fd0c6852607391296751fddc2b8f4553f68c3e" + }, + "Lean.Compiler.LCNF.Renaming": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Renaming.olean", + "sha256": "bddac036add967291692acef307d3315af8aed4fd89a18d34311ac694ecf7816" + }, + "Lean.Compiler.LCNF.ScopeM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ScopeM.olean", + "sha256": "28822aa06f00730aba221eb7ae6cb264bb494bf25280246ffe6ff36c76243d28" + }, + "Lean.Compiler.LCNF.Simp": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp.olean", + "sha256": "58be16412a7c090265590410396a8263ede4d980f046637dff96f4a94d5d0b43" + }, + "Lean.Compiler.LCNF.Simp.Basic": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Basic.olean", + "sha256": "0bef1c90ca8bed6f80869aeb298d70671f82c7eec6f32e4576cca8d078d2ddfd" + }, + "Lean.Compiler.LCNF.Simp.Config": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Config.olean", + "sha256": "df3ec1bf55fe323c59d24d9e289dbb55b8e4e153686895cb4c6efbf33e693392" + }, + "Lean.Compiler.LCNF.Simp.ConstantFold": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/ConstantFold.olean", + "sha256": "63f240d9e408f7f34c53731a4b40b6784f639f7df3a130297aa52df6c5868ca3" + }, + "Lean.Compiler.LCNF.Simp.DefaultAlt": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/DefaultAlt.olean", + "sha256": "c7e68d37f1843b498489140e970e2caaa36548918cae5ddd881236065fdf9dfa" + }, + "Lean.Compiler.LCNF.Simp.DiscrM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/DiscrM.olean", + "sha256": "484a04366395e90ad0b5dd5c692a9e0da30c0918f50cca2ce7dc4459fbd6a590" + }, + "Lean.Compiler.LCNF.Simp.FunDeclInfo": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/FunDeclInfo.olean", + "sha256": "63a8525abb01ee09dcd5fd7bb66fd5d5c9139ec98c9c4622594f19d042b7a81d" + }, + "Lean.Compiler.LCNF.Simp.InlineCandidate": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineCandidate.olean", + "sha256": "04353a98d60a93bb13f644bc92b81233d665eff28f5e2594d7b7a45ef883572c" + }, + "Lean.Compiler.LCNF.Simp.InlineProj": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/InlineProj.olean", + "sha256": "949390558396b4e92eb72823f8f123ce6a6a310b8e77234bd741d36a8158c1a4" + }, + "Lean.Compiler.LCNF.Simp.JpCases": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/JpCases.olean", + "sha256": "88b4036ff347ff9a1678d5eb585ca362ae0090e9de2b646e2efe90f4dc9a2328" + }, + "Lean.Compiler.LCNF.Simp.Main": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Main.olean", + "sha256": "0ae14b3273b7cb404efb46440a25ac0aaf8e49cd31eb57bea19b7833c219365b" + }, + "Lean.Compiler.LCNF.Simp.SimpM": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpM.olean", + "sha256": "df1538b785d0aaa55d1d73ab4b63fd693959896c231a826d39818bddcb6b0d08" + }, + "Lean.Compiler.LCNF.Simp.SimpValue": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/SimpValue.olean", + "sha256": "5de57ce90ffa7ba15734b33a8ad519ee98115c1e83f7ce047fcad5eb03bbe297" + }, + "Lean.Compiler.LCNF.Simp.Used": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Simp/Used.olean", + "sha256": "a4983d2052c84460309e9808f3d4518e65f78d7097eb707772abe71ba2bf5e4c" + }, + "Lean.Compiler.LCNF.SpecInfo": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/SpecInfo.olean", + "sha256": "4d9ce851163d5921bf6573eaf6b3d68442709f279fa96b23336b7b32d58a440b" + }, + "Lean.Compiler.LCNF.Specialize": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Specialize.olean", + "sha256": "9ecbcb6a200ec1984ed5231ba427a912a51177fbbfcf2d7ae584aba44397758b" + }, + "Lean.Compiler.LCNF.Testing": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Testing.olean", + "sha256": "8f082e72af8eb9e42eda181444b84c6a71e1a38e65b92e335abe9fda5f77d9cd" + }, + "Lean.Compiler.LCNF.ToDecl": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToDecl.olean", + "sha256": "edd9baf0d9dcc767a237f6ab3d3b8be89f5f7a8486579a61d92f3ee55c85ec8b" + }, + "Lean.Compiler.LCNF.ToExpr": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToExpr.olean", + "sha256": "97eb45572133529cfcd4d6581a8a27c406477191a1b027b7dbc8bbaf45bab62d" + }, + "Lean.Compiler.LCNF.ToLCNF": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToLCNF.olean", + "sha256": "3d2ca7cd028efcacaa2882570d10dd518c5a73860de6ceebb68658b3439607ab" + }, + "Lean.Compiler.LCNF.ToMono": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/ToMono.olean", + "sha256": "9c42901d6b7192fd65b8a5f809566805abc90063211569894835a17be53820b3" + }, + "Lean.Compiler.LCNF.Types": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Types.olean", + "sha256": "19db15eb19ec6842ff578614e85a7323642539fbb955b5912c170dec0eae2292" + }, + "Lean.Compiler.LCNF.Util": { + "relative_path": "lib/lean/Lean/Compiler/LCNF/Util.olean", + "sha256": "2a73fb99a3cb08e8a41425bc5ca182aaaa401508e583d6305a70868ea56208c3" + }, + "Lean.Compiler.Main": { + "relative_path": "lib/lean/Lean/Compiler/Main.olean", + "sha256": "9dc59f3522ff5c16389fc3454829050f7613c2f4175037beab5c0e4f86468de3" + }, + "Lean.Compiler.NameMangling": { + "relative_path": "lib/lean/Lean/Compiler/NameMangling.olean", + "sha256": "52aa954ea4c255de3c15968d309de875c4b03892e28568614f5b9e5d6bc3f38c" + }, + "Lean.Compiler.NeverExtractAttr": { + "relative_path": "lib/lean/Lean/Compiler/NeverExtractAttr.olean", + "sha256": "8efc3ead298e537a086cd425cfd99e6cd10185c78b13d8654d04435ed0f2c577" + }, + "Lean.Compiler.NoncomputableAttr": { + "relative_path": "lib/lean/Lean/Compiler/NoncomputableAttr.olean", + "sha256": "e396574927b99c247f101c8248a0a09cdff7a46e3809fb4589f0dcc4fba6d106" + }, + "Lean.Compiler.Old": { + "relative_path": "lib/lean/Lean/Compiler/Old.olean", + "sha256": "abc232855b58731d54ab07783fa46843208c6deace78b6b370cf476353c3e46d" + }, + "Lean.Compiler.Options": { + "relative_path": "lib/lean/Lean/Compiler/Options.olean", + "sha256": "b86376be11dc414b13c5a54d25cb7817f5660a01981e99d7f45f587f9a2933df" + }, + "Lean.Compiler.Specialize": { + "relative_path": "lib/lean/Lean/Compiler/Specialize.olean", + "sha256": "401294d22aa31d66ffea73cc8e81b84069c82bbf437abe562251e13bfd93394a" + }, + "Lean.CoreM": { + "relative_path": "lib/lean/Lean/CoreM.olean", + "sha256": "5e46337730d7e521a4ee2760c1adaea3e2862c5cc8006afed50f290ca2aafea7" + }, + "Lean.Data": { + "relative_path": "lib/lean/Lean/Data.olean", + "sha256": "3ea6fcf75dec1adae7990d5823a1527d3306689cb440e3c5ecea7b7ea7aab07d" + }, + "Lean.Data.Array": { + "relative_path": "lib/lean/Lean/Data/Array.olean", + "sha256": "d21870a1441bb3b382f82f64457d1fabeb8ab046e4147892433f89143f8481ea" + }, + "Lean.Data.AssocList": { + "relative_path": "lib/lean/Lean/Data/AssocList.olean", + "sha256": "9a08b7424a24c46dd2284b4c7b8692181a5e608302ae500e6445d627ea448d41" + }, + "Lean.Data.DeclarationRange": { + "relative_path": "lib/lean/Lean/Data/DeclarationRange.olean", + "sha256": "0c7a925cebc8a6c0405a7f6741afe5ecebca751b7141fc36518c902615167d6d" + }, + "Lean.Data.Format": { + "relative_path": "lib/lean/Lean/Data/Format.olean", + "sha256": "64c298e5e84c96a54830f2e1cf59e23ecd5c91c45336d9e99aa368884d8a9069" + }, + "Lean.Data.FuzzyMatching": { + "relative_path": "lib/lean/Lean/Data/FuzzyMatching.olean", + "sha256": "558ddc6d5ca38eada259e0fa5ad47478d15ba0f7878a7becb1c04394e7e98b19" + }, + "Lean.Data.Json": { + "relative_path": "lib/lean/Lean/Data/Json.olean", + "sha256": "3839c3f8868485cc28a91248414f8d7b15e3785cadd116d77d254f3acef1b768" + }, + "Lean.Data.Json.Basic": { + "relative_path": "lib/lean/Lean/Data/Json/Basic.olean", + "sha256": "d4a1599c4250412e05b960339e4898b1b5a9dde3f0292029eb02947f7df091cb" + }, + "Lean.Data.Json.Elab": { + "relative_path": "lib/lean/Lean/Data/Json/Elab.olean", + "sha256": "75bd0e3c0b0e50b6890616aff9499849bcc80f783737fb06762b1e638ce6641a" + }, + "Lean.Data.Json.FromToJson": { + "relative_path": "lib/lean/Lean/Data/Json/FromToJson.olean", + "sha256": "bc5266fe22b0d8289fac5e2194f2f3a5c0efa79dc538a96dee258041d8296066" + }, + "Lean.Data.Json.Parser": { + "relative_path": "lib/lean/Lean/Data/Json/Parser.olean", + "sha256": "eb9a4c2f421543848f9e21ff12b4cbf7ec42e0b339c4cc81725e9be627307a46" + }, + "Lean.Data.Json.Printer": { + "relative_path": "lib/lean/Lean/Data/Json/Printer.olean", + "sha256": "18bc6d83251888a60b8e091d5a7cd832d1733cca7cf8fc0afd197db2cd4bac6d" + }, + "Lean.Data.Json.Stream": { + "relative_path": "lib/lean/Lean/Data/Json/Stream.olean", + "sha256": "bbb7aea03b82669971dae676811dc7c4d2f91530d1b95dec8186faad10a2690e" + }, + "Lean.Data.JsonRpc": { + "relative_path": "lib/lean/Lean/Data/JsonRpc.olean", + "sha256": "324ae0dd9b94d607f0bd3634ff28ee91747e533225a1787ccffd3cdff6e78934" + }, + "Lean.Data.KVMap": { + "relative_path": "lib/lean/Lean/Data/KVMap.olean", + "sha256": "b69b36c839f87d7982c58dca02516af56a62b6e6f8cfed957727ab6fa5bdc3ac" + }, + "Lean.Data.LBool": { + "relative_path": "lib/lean/Lean/Data/LBool.olean", + "sha256": "e53d3d54cbdd02e971cade214336ed88039217dac49083fe9e2884774bc65980" + }, + "Lean.Data.LOption": { + "relative_path": "lib/lean/Lean/Data/LOption.olean", + "sha256": "ef57f5ca74f00d15e3353c7372bfd6539fad887f98eeb1405fc120f63fbc5450" + }, + "Lean.Data.Lsp": { + "relative_path": "lib/lean/Lean/Data/Lsp.olean", + "sha256": "5e8f95b054cf4f0bd78d09d3b60f8212677ebbcc9669810a4d555c12dbbe2c9d" + }, + "Lean.Data.Lsp.Basic": { + "relative_path": "lib/lean/Lean/Data/Lsp/Basic.olean", + "sha256": "10bd55152d2d3195bc716586b88ba354117a1610a511d4ef45e5bae4e47da591" + }, + "Lean.Data.Lsp.CancelParams": { + "relative_path": "lib/lean/Lean/Data/Lsp/CancelParams.olean", + "sha256": "34d5045104a2ad488db0eef5506fb5d152a50eb3b218963958249909e0693fc5" + }, + "Lean.Data.Lsp.Capabilities": { + "relative_path": "lib/lean/Lean/Data/Lsp/Capabilities.olean", + "sha256": "ea086554ff056336572f390c3a721392fc0a091b1e3ad5b11a1cbcfde01acb7d" + }, + "Lean.Data.Lsp.Client": { + "relative_path": "lib/lean/Lean/Data/Lsp/Client.olean", + "sha256": "66969eb1b65d7b7c0785a7410441db19c0684e49523b99141c98e9d6de265b1c" + }, + "Lean.Data.Lsp.CodeActions": { + "relative_path": "lib/lean/Lean/Data/Lsp/CodeActions.olean", + "sha256": "aaf6f59e076f612c399dc153b8655c630e5e8d3900d0c34e0754af24363fb5db" + }, + "Lean.Data.Lsp.Communication": { + "relative_path": "lib/lean/Lean/Data/Lsp/Communication.olean", + "sha256": "ff24b3db4d74dee7c02f3b312dfbcd8808ad401059a6e620467de85d2eae4b02" + }, + "Lean.Data.Lsp.Diagnostics": { + "relative_path": "lib/lean/Lean/Data/Lsp/Diagnostics.olean", + "sha256": "fab551e98e02150756f22d91f045edd2885311b0f2acd3b9f2518a03ac5315d1" + }, + "Lean.Data.Lsp.Extra": { + "relative_path": "lib/lean/Lean/Data/Lsp/Extra.olean", + "sha256": "328a92e6483fa971c03bc5c81df3fb8d54638f2b63589227cd51c150c184c6b3" + }, + "Lean.Data.Lsp.InitShutdown": { + "relative_path": "lib/lean/Lean/Data/Lsp/InitShutdown.olean", + "sha256": "6a4a2bdd2b9c291879021e2ac05ebb1766e5261b8eacce52931e0e3456e83582" + }, + "Lean.Data.Lsp.Internal": { + "relative_path": "lib/lean/Lean/Data/Lsp/Internal.olean", + "sha256": "7ac2bdcbc98918536b8dbc74f690ef33efa3d8f262d9da00b9745674124fa0f2" + }, + "Lean.Data.Lsp.Ipc": { + "relative_path": "lib/lean/Lean/Data/Lsp/Ipc.olean", + "sha256": "4655e8e87c7be2dee1388ddf2859e22126ff8e459049c7ae78b1f8c423523f60" + }, + "Lean.Data.Lsp.LanguageFeatures": { + "relative_path": "lib/lean/Lean/Data/Lsp/LanguageFeatures.olean", + "sha256": "9076799ae1e2a126180f4b65b4ba70bd0587000bbba075a49ede2e652940f648" + }, + "Lean.Data.Lsp.TextSync": { + "relative_path": "lib/lean/Lean/Data/Lsp/TextSync.olean", + "sha256": "661e837c6457b276db0fc3ff7b83c025daed1e81f1d119fa2bd8d8f703507212" + }, + "Lean.Data.Lsp.Utf16": { + "relative_path": "lib/lean/Lean/Data/Lsp/Utf16.olean", + "sha256": "3b966b6509a39ebdcfad59afb26a19c8b1ba431328424700a06d2f157e4628a2" + }, + "Lean.Data.Lsp.Window": { + "relative_path": "lib/lean/Lean/Data/Lsp/Window.olean", + "sha256": "80692ee76bcb8185fa3f79531823189b4aec6a02471db5978a0d41c260482632" + }, + "Lean.Data.Lsp.Workspace": { + "relative_path": "lib/lean/Lean/Data/Lsp/Workspace.olean", + "sha256": "9e2c734db08fbbf1a7eecf54afa2f4e6b2c4823fbfec4a700ca1ede9cbf099a8" + }, + "Lean.Data.Name": { + "relative_path": "lib/lean/Lean/Data/Name.olean", + "sha256": "608a86b16dc2e68888780aace6bf3c444be9ca982fbe05c0722b24a5941114cf" + }, + "Lean.Data.NameMap": { + "relative_path": "lib/lean/Lean/Data/NameMap.olean", + "sha256": "ad3950d1e39be7f250a74794819b4c299fd8aad0b95a8ebf383f713c4648667b" + }, + "Lean.Data.NameTrie": { + "relative_path": "lib/lean/Lean/Data/NameTrie.olean", + "sha256": "7b0032738d09c94b21eedfb74e920ce5781c864cc1541e28b9216f2296a3f50a" + }, + "Lean.Data.OpenDecl": { + "relative_path": "lib/lean/Lean/Data/OpenDecl.olean", + "sha256": "11d3c7dfac1707956e6ad5f8d99249971cefd2439d94b1042efcf1147a609848" + }, + "Lean.Data.Options": { + "relative_path": "lib/lean/Lean/Data/Options.olean", + "sha256": "69369d0818d266e890c00e318f186fdb767b308ec0ffa12c8d498ad8ab8dafd4" + }, + "Lean.Data.PersistentArray": { + "relative_path": "lib/lean/Lean/Data/PersistentArray.olean", + "sha256": "14912531f574091502391030308b9fe1d9d6751b946af2614e19472c009ed084" + }, + "Lean.Data.PersistentHashMap": { + "relative_path": "lib/lean/Lean/Data/PersistentHashMap.olean", + "sha256": "1eb926bd3f03db27a647b1dd1ae1606722f7f8bd555a8c9e4197e00d69af8819" + }, + "Lean.Data.PersistentHashSet": { + "relative_path": "lib/lean/Lean/Data/PersistentHashSet.olean", + "sha256": "bbe6fe443d42b01b3ee7c45908dd2761f3e0996e47c6d05531bfd326b82a1927" + }, + "Lean.Data.Position": { + "relative_path": "lib/lean/Lean/Data/Position.olean", + "sha256": "1031cb2dd0a833b50284a503a02c8f71490d93182219e9b2e43c536370992719" + }, + "Lean.Data.PrefixTree": { + "relative_path": "lib/lean/Lean/Data/PrefixTree.olean", + "sha256": "1cfc295f1fee5de8bb9c641f6c6a67ed4d24b3cea24af1b44ce8baae361860d7" + }, + "Lean.Data.RArray": { + "relative_path": "lib/lean/Lean/Data/RArray.olean", + "sha256": "6846f637e7f46e1ed281043406f082980d0db3c56fd1fc34fd080be3e743b11a" + }, + "Lean.Data.RBMap": { + "relative_path": "lib/lean/Lean/Data/RBMap.olean", + "sha256": "ecdafd26877ccf099c7ad634090493a314130ddb1f511402e869f833179f677a" + }, + "Lean.Data.RBTree": { + "relative_path": "lib/lean/Lean/Data/RBTree.olean", + "sha256": "4a1139cda04f91a7a78086a92cbfa53af7cd5ed0b04f50f388e91caba39e72c4" + }, + "Lean.Data.SMap": { + "relative_path": "lib/lean/Lean/Data/SMap.olean", + "sha256": "1af0bd0e0119f17204517f5b0e3ae76e582ad139d167e04d4b872c3b80fb9446" + }, + "Lean.Data.SSet": { + "relative_path": "lib/lean/Lean/Data/SSet.olean", + "sha256": "3ce020534c8de2eaaf8b72fdc30dfeff283d9fdf9cb402ee7eaa9d6e06bed49a" + }, + "Lean.Data.Trie": { + "relative_path": "lib/lean/Lean/Data/Trie.olean", + "sha256": "425b99d0861d274a027650fd85e91fe2ea4c8d2b332c26f05ce3faa69f8b22a9" + }, + "Lean.Data.Xml": { + "relative_path": "lib/lean/Lean/Data/Xml.olean", + "sha256": "3051520fc1f5e8969c97cd69b2e390cc0291e716af0304ca910917ca40c395b6" + }, + "Lean.Data.Xml.Basic": { + "relative_path": "lib/lean/Lean/Data/Xml/Basic.olean", + "sha256": "b78909fa2d132e4733174d2ce5edb87022889a3c00034a5600c37366d1249798" + }, + "Lean.Data.Xml.Parser": { + "relative_path": "lib/lean/Lean/Data/Xml/Parser.olean", + "sha256": "ef6845551edad3dd21f97bc12796643808c3e736f98ea92cd3836de8d120f896" + }, + "Lean.Declaration": { + "relative_path": "lib/lean/Lean/Declaration.olean", + "sha256": "34e3ddb2ffb4c62a725faaa32d867b47ce0f0e88e4d05b88cb4b0e8d06afcf14" + }, + "Lean.DeclarationRange": { + "relative_path": "lib/lean/Lean/DeclarationRange.olean", + "sha256": "0acae02702629cf9d8d1914af744e4616b1a11ec0c36b87b061ddb544de6c77f" + }, + "Lean.DocString": { + "relative_path": "lib/lean/Lean/DocString.olean", + "sha256": "a3acd1c0a67f2041105b56e4358104b944cccadaf6282f51d2d6c92c588e1322" + }, + "Lean.DocString.Add": { + "relative_path": "lib/lean/Lean/DocString/Add.olean", + "sha256": "4e2edfbc5d94f30cb22899dd904adf4e886c31d74a14b4867d5e6990ae6bef1f" + }, + "Lean.DocString.Extension": { + "relative_path": "lib/lean/Lean/DocString/Extension.olean", + "sha256": "62da3e2b1a78c1564bc55d7a62a3dd0bf3a5bb680c78b064545b34f22ff5f594" + }, + "Lean.DocString.Links": { + "relative_path": "lib/lean/Lean/DocString/Links.olean", + "sha256": "cb06ad02ed13e3becad26e41c65955dc450c95efd3c03c7e243480eb441a280e" + }, + "Lean.Elab": { + "relative_path": "lib/lean/Lean/Elab.olean", + "sha256": "fb002575329248f441db46568924da0347c0fc94899a897d260ed87e8b060d3a" + }, + "Lean.Elab.App": { + "relative_path": "lib/lean/Lean/Elab/App.olean", + "sha256": "7f2ef3399ca2be27e53f782db9299d1262626709416ecbde404d3044360c20e2" + }, + "Lean.Elab.Arg": { + "relative_path": "lib/lean/Lean/Elab/Arg.olean", + "sha256": "43fcac69dfb8c829f70e5c25b51a6864a5926de26a7f59d59b3434c77d2a4b70" + }, + "Lean.Elab.Attributes": { + "relative_path": "lib/lean/Lean/Elab/Attributes.olean", + "sha256": "a5a66de9739bb05ccb5303622d7e370cb631c209bade735a5a9263a16f2e994e" + }, + "Lean.Elab.AutoBound": { + "relative_path": "lib/lean/Lean/Elab/AutoBound.olean", + "sha256": "bf849b5b3131ab0c7cd465721e2bff12b3007ab05787e45d9c45cfe31dbcd8d9" + }, + "Lean.Elab.AuxDef": { + "relative_path": "lib/lean/Lean/Elab/AuxDef.olean", + "sha256": "a48e7422c13ae3730a198f9535a2a4f1d52af7ddff79a8e3e44f17e382bded85" + }, + "Lean.Elab.BinderPredicates": { + "relative_path": "lib/lean/Lean/Elab/BinderPredicates.olean", + "sha256": "f19b46d5afb2ed4f25501c99c971d43ef80056b1b54537acfab9b844b4baa033" + }, + "Lean.Elab.Binders": { + "relative_path": "lib/lean/Lean/Elab/Binders.olean", + "sha256": "5382842df889f912fcdc6829b4da03bccb31d24f644c9dc267d549a049f1f6e2" + }, + "Lean.Elab.BindersUtil": { + "relative_path": "lib/lean/Lean/Elab/BindersUtil.olean", + "sha256": "dab5459f96c9af7151e019d42c16f735587fe9d2e465680af5542694045d024e" + }, + "Lean.Elab.BuiltinCommand": { + "relative_path": "lib/lean/Lean/Elab/BuiltinCommand.olean", + "sha256": "e8873e484147230a2d52ed220e5d991242e27b35cb3e04ac44a121b4e60674e6" + }, + "Lean.Elab.BuiltinEvalCommand": { + "relative_path": "lib/lean/Lean/Elab/BuiltinEvalCommand.olean", + "sha256": "c9ffac4f0e2a910c88b947565e7186e7496b2bb71a51d3efa8b57df1716e2721" + }, + "Lean.Elab.BuiltinNotation": { + "relative_path": "lib/lean/Lean/Elab/BuiltinNotation.olean", + "sha256": "a8854418983a3521ac0009f1d1bc5886cbee99a420b5853c955e2bba669c8a01" + }, + "Lean.Elab.BuiltinTerm": { + "relative_path": "lib/lean/Lean/Elab/BuiltinTerm.olean", + "sha256": "d1c759f9d638631d8c7fcc61d904c4b3022e467c85374536404b62bcae94dbfa" + }, + "Lean.Elab.Calc": { + "relative_path": "lib/lean/Lean/Elab/Calc.olean", + "sha256": "517858cf70dbd5a3567f8c7efa08ebb072924f0ab475d1ea392d2d71f404a067" + }, + "Lean.Elab.CheckTactic": { + "relative_path": "lib/lean/Lean/Elab/CheckTactic.olean", + "sha256": "4ee79b7594813f45a0be34f47d7dcb9040038d236c08d62d075bb533cd209a06" + }, + "Lean.Elab.Command": { + "relative_path": "lib/lean/Lean/Elab/Command.olean", + "sha256": "d70527ba43f3a254e944e0951c798896a50306d8eb16d8caf346cc2c8de2037e" + }, + "Lean.Elab.ComputedFields": { + "relative_path": "lib/lean/Lean/Elab/ComputedFields.olean", + "sha256": "8aa833985762117070e65be8efd47e1105136cb60c5dce5bd1c3d9b777829778" + }, + "Lean.Elab.Config": { + "relative_path": "lib/lean/Lean/Elab/Config.olean", + "sha256": "ab8b7261941780805d87f6cd63432afa539d6810b16b3728dfa0be2722c36bd4" + }, + "Lean.Elab.DeclModifiers": { + "relative_path": "lib/lean/Lean/Elab/DeclModifiers.olean", + "sha256": "082924ed9a1233708427a204ac06d00058e16efc75a4fbf2b05260bd4b4d23d9" + }, + "Lean.Elab.DeclNameGen": { + "relative_path": "lib/lean/Lean/Elab/DeclNameGen.olean", + "sha256": "3074bf25442d70036c97fadd21d83594e0b375d89a203068ccdcfbd5ac0778ab" + }, + "Lean.Elab.DeclUtil": { + "relative_path": "lib/lean/Lean/Elab/DeclUtil.olean", + "sha256": "60ed8c5034fdb91d96f0d29a947ae510e6aa2d2c8144c82d941b33d8a236cef2" + }, + "Lean.Elab.Declaration": { + "relative_path": "lib/lean/Lean/Elab/Declaration.olean", + "sha256": "60127f7068dd6080656cc0b8fc28c04e2297a8c22ed96c5ebc6a940bb746f3d6" + }, + "Lean.Elab.DeclarationRange": { + "relative_path": "lib/lean/Lean/Elab/DeclarationRange.olean", + "sha256": "4f693d72400c7b0083dc440da6cd99962551af0a31fcdc5f23ad218b4c1cf9ba" + }, + "Lean.Elab.DefView": { + "relative_path": "lib/lean/Lean/Elab/DefView.olean", + "sha256": "4b0690fe469dcc04235e5f1db28aca28c0a1d1890622e846894836d8465cbe27" + }, + "Lean.Elab.Deriving": { + "relative_path": "lib/lean/Lean/Elab/Deriving.olean", + "sha256": "ce2343744dcd7113446dba7686175adce1b219cfa3e2a02b883dc96c83ba7492" + }, + "Lean.Elab.Deriving.BEq": { + "relative_path": "lib/lean/Lean/Elab/Deriving/BEq.olean", + "sha256": "9ee4fb8b5a18bc9a71a2188781679f93e6f7084d7166d0abca3348a2ea069748" + }, + "Lean.Elab.Deriving.Basic": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Basic.olean", + "sha256": "1ce625bec288e07f709d51fce4479fa7c90fa26229a535dbf101fb15f094b1f4" + }, + "Lean.Elab.Deriving.DecEq": { + "relative_path": "lib/lean/Lean/Elab/Deriving/DecEq.olean", + "sha256": "02f7fe725e01d8646ab570659983869355626c34eba194247edcef78ec767253" + }, + "Lean.Elab.Deriving.FromToJson": { + "relative_path": "lib/lean/Lean/Elab/Deriving/FromToJson.olean", + "sha256": "02247476a022d1f65eedd2bd2edc694bd4dad5f4766c175b99613a7f7573c7a8" + }, + "Lean.Elab.Deriving.Hashable": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Hashable.olean", + "sha256": "d6a8f5480a4d92cad91e38425026a73585933acdea29983327c6847c2b262f88" + }, + "Lean.Elab.Deriving.Inhabited": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Inhabited.olean", + "sha256": "39f9db1e14cd9748ee9fa5d6a892f8aea231b94d854d6b18d8386ef424f71e2d" + }, + "Lean.Elab.Deriving.Nonempty": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Nonempty.olean", + "sha256": "99cf8010b9439d9586ec46c94e4667b1a779478c343adeddb8744e3e9a40b8f6" + }, + "Lean.Elab.Deriving.Ord": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Ord.olean", + "sha256": "4a047b2d5dfcd783ad4004184a3752bd8a7ab07dd8a694e097d1d935e2935e9e" + }, + "Lean.Elab.Deriving.Repr": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Repr.olean", + "sha256": "6b3f39ea3a48df4fcdc3f54f23443e518331051c09c139e251e24e08830be248" + }, + "Lean.Elab.Deriving.SizeOf": { + "relative_path": "lib/lean/Lean/Elab/Deriving/SizeOf.olean", + "sha256": "e92edf4220bbfd45b65b0fec728a4e4d4cd94681b03bba266afa98e2615b9723" + }, + "Lean.Elab.Deriving.ToExpr": { + "relative_path": "lib/lean/Lean/Elab/Deriving/ToExpr.olean", + "sha256": "d6523a528599743a7df654f5743b1528f21614d72a44f3abe2aa8a28d3bd648d" + }, + "Lean.Elab.Deriving.TypeName": { + "relative_path": "lib/lean/Lean/Elab/Deriving/TypeName.olean", + "sha256": "c4792fb38b5aeb5ea5a62636aff5f757d361aa8efd4f18c67004aae538a459b7" + }, + "Lean.Elab.Deriving.Util": { + "relative_path": "lib/lean/Lean/Elab/Deriving/Util.olean", + "sha256": "c12884adaa0c778910c1bb93eaed6108bdaea5154acf789cfade6ed2d07bc557" + }, + "Lean.Elab.Do": { + "relative_path": "lib/lean/Lean/Elab/Do.olean", + "sha256": "f7edfae85cb0c26decf417da2b632bd988396e64b591ed1e83d80007039803f3" + }, + "Lean.Elab.ElabRules": { + "relative_path": "lib/lean/Lean/Elab/ElabRules.olean", + "sha256": "f9382a01adb96c2df46c91c3b8f089161a092e303fa6c21f6ee11e052b6ff4a2" + }, + "Lean.Elab.Eval": { + "relative_path": "lib/lean/Lean/Elab/Eval.olean", + "sha256": "7c71d21984db41ed525d830c97c499f6b6bb94896b3ef708a3f0f3c3992816be" + }, + "Lean.Elab.Exception": { + "relative_path": "lib/lean/Lean/Elab/Exception.olean", + "sha256": "c1966d832888ab689c6fb710ec26064030ce9114979ba2be5b55438d3a588875" + }, + "Lean.Elab.Extra": { + "relative_path": "lib/lean/Lean/Elab/Extra.olean", + "sha256": "e04aa742507f1f8ce71235aee3e0410a0349afcce02af8033eda84793fd3cb07" + }, + "Lean.Elab.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Frontend.olean", + "sha256": "8a78aa55e40dc042d0ef7ee6eb0ac9a8e32e69499d416edbeaf41a87389bdfcc" + }, + "Lean.Elab.GenInjective": { + "relative_path": "lib/lean/Lean/Elab/GenInjective.olean", + "sha256": "71e9b7c42d5c7ba361b678074beaa897c5d59561f84b92e61be9bce93ba1516c" + }, + "Lean.Elab.GuardMsgs": { + "relative_path": "lib/lean/Lean/Elab/GuardMsgs.olean", + "sha256": "c31104fae5363b5f9b40b457899730f0bf09cb532dbdba7019768a491bfbe033" + }, + "Lean.Elab.Import": { + "relative_path": "lib/lean/Lean/Elab/Import.olean", + "sha256": "942d562b54b0f9c16191c1dc631a63c61242e662bb6b20a96c21aca07febd4a2" + }, + "Lean.Elab.Inductive": { + "relative_path": "lib/lean/Lean/Elab/Inductive.olean", + "sha256": "c0773865c8c9ed8cf8dd1799819033f043b272ece64a17dcfca9c393fc65d4d1" + }, + "Lean.Elab.InfoTree": { + "relative_path": "lib/lean/Lean/Elab/InfoTree.olean", + "sha256": "e70760b7a719b09450ee47e653758f4b04bf770d2540ecdad9c68e1ff9dcffb1" + }, + "Lean.Elab.InfoTree.InlayHints": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/InlayHints.olean", + "sha256": "9ba09f4498147935a7cc795b4dbeb9c50d057cf40bd69dc080cabcb53c6f528a" + }, + "Lean.Elab.InfoTree.Main": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/Main.olean", + "sha256": "1d24d8fe2cf5c200615e2441353a8f2ccb183bd92272ad1a91c143f037e59159" + }, + "Lean.Elab.InfoTree.Types": { + "relative_path": "lib/lean/Lean/Elab/InfoTree/Types.olean", + "sha256": "f5ef787b574b053eb6c4dedb63628dcab9c3323860e03b9f1689b919f5a43ea6" + }, + "Lean.Elab.InfoTrees": { + "relative_path": "lib/lean/Lean/Elab/InfoTrees.olean", + "sha256": "6d9c5aef462dd3f15682d204244f1f309fe21ef6ef10afb72805a052e7360f97" + }, + "Lean.Elab.InheritDoc": { + "relative_path": "lib/lean/Lean/Elab/InheritDoc.olean", + "sha256": "13baf3bf2e721fe666937e96ef2e4c05b29802168cdbd1dbcb5024ff90c12808" + }, + "Lean.Elab.LetRec": { + "relative_path": "lib/lean/Lean/Elab/LetRec.olean", + "sha256": "25dedf0d0c914e81ba7d5f40d8cac33b777717b8587e668add128fd532e0a129" + }, + "Lean.Elab.Level": { + "relative_path": "lib/lean/Lean/Elab/Level.olean", + "sha256": "6a2e73a7585f6edbc7aa991ced908c75f6a0b6677c602f9688c2187f4e424507" + }, + "Lean.Elab.Macro": { + "relative_path": "lib/lean/Lean/Elab/Macro.olean", + "sha256": "6d4ddaaad390cc33240dabfe92351ce1b4475bc00e2bfc13a1e7d1275b731e9c" + }, + "Lean.Elab.MacroArgUtil": { + "relative_path": "lib/lean/Lean/Elab/MacroArgUtil.olean", + "sha256": "66055bb8c852b726c6c019c0ea30d9680da2b79d0f7281bae9dd6aac4e69c745" + }, + "Lean.Elab.MacroRules": { + "relative_path": "lib/lean/Lean/Elab/MacroRules.olean", + "sha256": "87258a9723089efebfd06f4fd21de2d60819043181f411caf52db4e4d61c9269" + }, + "Lean.Elab.Match": { + "relative_path": "lib/lean/Lean/Elab/Match.olean", + "sha256": "f96ca7fa6ad4572f2e70f9caf0017d6b703f6343f966146652b6a4567e075ecb" + }, + "Lean.Elab.MatchAltView": { + "relative_path": "lib/lean/Lean/Elab/MatchAltView.olean", + "sha256": "bcc410a60ab916611cd1314ccb349d1e6291534e2f54f1acc879ae5dd92e127e" + }, + "Lean.Elab.MatchExpr": { + "relative_path": "lib/lean/Lean/Elab/MatchExpr.olean", + "sha256": "c4a41299da81eb484f5ed9c1f11a2ea202f408aedd6f89eec668ec2309a05668" + }, + "Lean.Elab.Mixfix": { + "relative_path": "lib/lean/Lean/Elab/Mixfix.olean", + "sha256": "9a948b85420661584f24c9c1adb6e9de9d89e53b1c9a71f91ebc0c27b7664c6b" + }, + "Lean.Elab.MutualDef": { + "relative_path": "lib/lean/Lean/Elab/MutualDef.olean", + "sha256": "1f9b71fb58473a9ed15668ce35710aadb27f433aa3d403cb989ae40f4f22c468" + }, + "Lean.Elab.MutualInductive": { + "relative_path": "lib/lean/Lean/Elab/MutualInductive.olean", + "sha256": "cadab2c90a0b83ef83df3405057155eceeb5335b3496f9f380677d08a5d03cf0" + }, + "Lean.Elab.Notation": { + "relative_path": "lib/lean/Lean/Elab/Notation.olean", + "sha256": "48412518cf3a658eae49c64cc1467c82b71bc9d8210744b25af28f2c920335ed" + }, + "Lean.Elab.Open": { + "relative_path": "lib/lean/Lean/Elab/Open.olean", + "sha256": "871d01b5e8a7d02623aae31186f1d6440de1e88cfa5a61aa65d49bc339b801b1" + }, + "Lean.Elab.ParseImportsFast": { + "relative_path": "lib/lean/Lean/Elab/ParseImportsFast.olean", + "sha256": "e7c263fcce8f9f845a93cbacd4270d29f526c6f49542bfd3fabda67b7bf6a78a" + }, + "Lean.Elab.PatternVar": { + "relative_path": "lib/lean/Lean/Elab/PatternVar.olean", + "sha256": "cc24f76e8a73bb74fa086ffc0ca15b83727e9fe862a2bebeb5ef951d328568ec" + }, + "Lean.Elab.PreDefinition": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition.olean", + "sha256": "cf08e93464411219890b4cb1bab8e1610a70a4fb65e43b50bd739539ef367547" + }, + "Lean.Elab.PreDefinition.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Basic.olean", + "sha256": "e37a918d0df8abd0297fe32ffe904d12705e71a5098c0c3299788bec711135d8" + }, + "Lean.Elab.PreDefinition.EqUnfold": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/EqUnfold.olean", + "sha256": "3461b20ecf2a82f12d463ada0c8741fa66ee5d67ad1f6baf6e744166ccecb007" + }, + "Lean.Elab.PreDefinition.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Eqns.olean", + "sha256": "19c4d86d1bc0cb30d41db8fee326500bff23ce73f35d422a577d118a346c3f4c" + }, + "Lean.Elab.PreDefinition.FixedParams": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/FixedParams.olean", + "sha256": "0b2ab92716760dec18c20cef92a923f45ced48471005b89968dc44cc042a7787" + }, + "Lean.Elab.PreDefinition.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Main.olean", + "sha256": "e9da272ef4937c5dea929555f1afb9c0bc5e546c46ba077dba6ecad53fc039f9" + }, + "Lean.Elab.PreDefinition.MkInhabitant": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/MkInhabitant.olean", + "sha256": "01386a0e9abb41906ebeff2b51300a35bdb976fd8f5414996e90edbe7aa71535" + }, + "Lean.Elab.PreDefinition.Mutual": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Mutual.olean", + "sha256": "7727402f03f91af4db7349660aa7d8ea7512be3c6a5a9745e4528df91b2d86e2" + }, + "Lean.Elab.PreDefinition.Nonrec.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Nonrec/Eqns.olean", + "sha256": "3651d817386974e312357f20f0f5b695df32636b45ad87bf257e12333522f7de" + }, + "Lean.Elab.PreDefinition.PartialFixpoint": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint.olean", + "sha256": "e66825e384ff17dc6519d4c3bbb1e2d437fb9d06ccd62c25ae39462160bb8a74" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Eqns.olean", + "sha256": "dfaf14ede280a406724d7388dfd50253eb1f72bc95053c73e5b5ec562eb13181" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Induction": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Induction.olean", + "sha256": "ace8bf806b6e3c115ca8dca8903b2590944121d6ee15b166a9e90d26f8c65de2" + }, + "Lean.Elab.PreDefinition.PartialFixpoint.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/PartialFixpoint/Main.olean", + "sha256": "ce6f69f8a60fbf4529c56fb9d180b9848c4dc94b0924669d52edadea1eea85da" + }, + "Lean.Elab.PreDefinition.Structural": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural.olean", + "sha256": "5df5e860a2941222d125302b6992dfee99076a8dfe7635e03d0067b1de52037b" + }, + "Lean.Elab.PreDefinition.Structural.BRecOn": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/BRecOn.olean", + "sha256": "43d778c2e31237bab4927df047f983f90d8e51f0c8994766eade48f3cf6ac721" + }, + "Lean.Elab.PreDefinition.Structural.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Basic.olean", + "sha256": "b9c232de8b46027f3e53de76dcd73a120fe39c3d59967a5a5d4b770687546ff6" + }, + "Lean.Elab.PreDefinition.Structural.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Eqns.olean", + "sha256": "1ab842d0ec3f072b7ef36c3c389106b6281772e9c39077183524e8a7b2df26d4" + }, + "Lean.Elab.PreDefinition.Structural.FindRecArg": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/FindRecArg.olean", + "sha256": "22c836971360cfbae10b952afc57c8cceea7c6e0776bc4f5785db9f56231f4dc" + }, + "Lean.Elab.PreDefinition.Structural.IndGroupInfo": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndGroupInfo.olean", + "sha256": "bcbc74eedc2f318a8b2b3f67dee27bbad4499edf1b90e1b5ef2f97392829471e" + }, + "Lean.Elab.PreDefinition.Structural.IndPred": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/IndPred.olean", + "sha256": "933c5f3adb300c234bc4b21c33ac88720ce348df0da6101f5e29e82e2c9ebd09" + }, + "Lean.Elab.PreDefinition.Structural.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Main.olean", + "sha256": "c4239a1efe6ae90a63a33c58a2a4416ad6811c5b137a4fff5e14dea0c97dbf4e" + }, + "Lean.Elab.PreDefinition.Structural.Preprocess": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/Preprocess.olean", + "sha256": "da41c20561ffeedc9fa735b40812cfc6f2019cb4ae039fcc9b50bdb3c4b42beb" + }, + "Lean.Elab.PreDefinition.Structural.RecArgInfo": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/RecArgInfo.olean", + "sha256": "374c899afb685ea073722e49bbec2c586e1a3f301580147f1092dce75749f0e9" + }, + "Lean.Elab.PreDefinition.Structural.SmartUnfolding": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/Structural/SmartUnfolding.olean", + "sha256": "a3bb8c3544d361c4654090f576b2f089aca1931220817eadc9e6fde12d8d2e84" + }, + "Lean.Elab.PreDefinition.TerminationHint": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/TerminationHint.olean", + "sha256": "b008cd03dae9e9eb39f7c961783c7688bb0079c86b3380e5a2acba0931c96912" + }, + "Lean.Elab.PreDefinition.TerminationMeasure": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/TerminationMeasure.olean", + "sha256": "7b6a83a24610cdb1a23a9e279cc4e2490f0984dc226172227a54b14653bc04b5" + }, + "Lean.Elab.PreDefinition.WF": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF.olean", + "sha256": "d756a42673113d104a8f1f10ec8e5266fd550ab3307d74635cff1a79dfdf50ee" + }, + "Lean.Elab.PreDefinition.WF.Basic": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Basic.olean", + "sha256": "30e303f01dd11f5bfb9bfe9f0ac7281cb267c79ee600883e9b75ec7ef3269c4a" + }, + "Lean.Elab.PreDefinition.WF.Eqns": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Eqns.olean", + "sha256": "cbcee84f0b521613f3b81a830c4672dcec0ec776d61e47ac8e8a6b323e9d8dda" + }, + "Lean.Elab.PreDefinition.WF.Fix": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Fix.olean", + "sha256": "1cd3b02dd48b1739fbdd069bca0f18019590476d52d0b55f770483952212ed4c" + }, + "Lean.Elab.PreDefinition.WF.FloatRecApp": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/FloatRecApp.olean", + "sha256": "2b2b7508f7f5f71d39f30b406dc2b24879727bee44615b1eabe341e1df9438e1" + }, + "Lean.Elab.PreDefinition.WF.GuessLex": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/GuessLex.olean", + "sha256": "193a0f7bb3f60de6c3af28362ca4e34e9e5812f17dc23e55e448a949992f31df" + }, + "Lean.Elab.PreDefinition.WF.Main": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Main.olean", + "sha256": "f877b579eeead916865fd609fde94addce79bb845e0d983e5733a88485a5766c" + }, + "Lean.Elab.PreDefinition.WF.PackMutual": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/PackMutual.olean", + "sha256": "2a5db58f9cf338b84db997411fc33bfe8e86284d92310df8c5de6e0b4319267f" + }, + "Lean.Elab.PreDefinition.WF.Preprocess": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Preprocess.olean", + "sha256": "1c2bd7a90e2254ed6d603023a49e6171f7c0d9a14b5516b28a4c216f5006fea9" + }, + "Lean.Elab.PreDefinition.WF.Rel": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Rel.olean", + "sha256": "c5bc9c3e5ac6b953c20efa66eb36629b6b957e1b043e34c4bc970e0c86aa0c11" + }, + "Lean.Elab.PreDefinition.WF.Unfold": { + "relative_path": "lib/lean/Lean/Elab/PreDefinition/WF/Unfold.olean", + "sha256": "e6f3e0b9a8ac077b6329df9ed9c09f78cd31e02841a3511420ee8e65d226bbe6" + }, + "Lean.Elab.Print": { + "relative_path": "lib/lean/Lean/Elab/Print.olean", + "sha256": "51e5f29b3d8074b0a7162eff78b664217a5dbc27efb76b145dbaea0c05c34a96" + }, + "Lean.Elab.Quotation": { + "relative_path": "lib/lean/Lean/Elab/Quotation.olean", + "sha256": "71b2f7b722ffcaeb09b2708d6bc5d6ff5cf1c17b12376699ea36d61f4b422eed" + }, + "Lean.Elab.Quotation.Precheck": { + "relative_path": "lib/lean/Lean/Elab/Quotation/Precheck.olean", + "sha256": "991a462e6701ed3ac0da579a5f9f2c7f7f666f3c9841eda19c86bb9576108653" + }, + "Lean.Elab.Quotation.Util": { + "relative_path": "lib/lean/Lean/Elab/Quotation/Util.olean", + "sha256": "f1eb03e06f604ef25245d13da5f6e5884e335fbb462b85cc25d2fddb1799a7fd" + }, + "Lean.Elab.RecAppSyntax": { + "relative_path": "lib/lean/Lean/Elab/RecAppSyntax.olean", + "sha256": "6abcf436c2719a2ec1d8bd634b141bc3276d0bf3e27e3cf005ea336fc9663bb7" + }, + "Lean.Elab.RecommendedSpelling": { + "relative_path": "lib/lean/Lean/Elab/RecommendedSpelling.olean", + "sha256": "9661fccfded1a3c1cfa6fd6ffb7d563b2884d98e4e644ab18eca9200cbebfab6" + }, + "Lean.Elab.SetOption": { + "relative_path": "lib/lean/Lean/Elab/SetOption.olean", + "sha256": "787c484587500ec3158e59ca10eebfea0af7d3083806a9471891821f6495a64d" + }, + "Lean.Elab.StructInst": { + "relative_path": "lib/lean/Lean/Elab/StructInst.olean", + "sha256": "47bb7c2c4610c8d54accb1bd6542626bb9d4b08e731135120c54cc9b9952abec" + }, + "Lean.Elab.Structure": { + "relative_path": "lib/lean/Lean/Elab/Structure.olean", + "sha256": "156b1283480708d45f2d4ccb21165c157b65fafa79490d678b5b221e6ee0b44e" + }, + "Lean.Elab.Syntax": { + "relative_path": "lib/lean/Lean/Elab/Syntax.olean", + "sha256": "6aad81137b009aa764c5d98639ee5fb600f0ce6fc27cdef1e073588a4c223986" + }, + "Lean.Elab.SyntheticMVars": { + "relative_path": "lib/lean/Lean/Elab/SyntheticMVars.olean", + "sha256": "765f17386784a6540f899b2af62be08e7b576a00a78f41584973b8fabf27d621" + }, + "Lean.Elab.Tactic": { + "relative_path": "lib/lean/Lean/Elab/Tactic.olean", + "sha256": "a8372c1c69001269930b6cbb4e881b9e8b593ac0d594e93ec7e6d361eaf3c368" + }, + "Lean.Elab.Tactic.AsAuxLemma": { + "relative_path": "lib/lean/Lean/Elab/Tactic/AsAuxLemma.olean", + "sha256": "3ab8861debb8b53d853057c0c66642079e60144679861402226630668939e906" + }, + "Lean.Elab.Tactic.BVDecide": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide.olean", + "sha256": "6736cf5da5943762151cf22c1342fc178f0f295bee9aeb7cf004c317aa45a07d" + }, + "Lean.Elab.Tactic.BVDecide.External": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/External.olean", + "sha256": "50fecaf48258db97412a2cafd593773db1dfa2339c681a31a4102f808b7a1327" + }, + "Lean.Elab.Tactic.BVDecide.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend.olean", + "sha256": "1336b674c40caf3ba24bb63e4b78ac58dee96d925c2fcc3036283109aaf823d0" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Attr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Attr.olean", + "sha256": "7a316bf1617de928f47afdd80f6ca28befae2fe6ad6b96dac4b7e290360f579b" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVCheck": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVCheck.olean", + "sha256": "75b4d47160ec998fe08da4884247a1cea961fad7e19bf6357670f6f626d5f036" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide.olean", + "sha256": "6557c91e5d2a05ba4a56c820828531dab370c1809771585e49a7b96a9a40ac75" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reflect.olean", + "sha256": "2b22721a88841e65d1256e7d6b3a7132b26ff1197f1ca65e3be5a5eb21422d49" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVExpr.olean", + "sha256": "7f79411de643ca37c169708a76aa12321701070ad666f41c243b1c6df2f52e07" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVLogical.olean", + "sha256": "3fa0a32b34699ba1f97db7c29be8d8b88b47c47e52de12f6191d5e6327c613b4" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedBVPred.olean", + "sha256": "a04f49452a90cab257db038fe0025d6e9b9f72ee3313a479b99fcac4ae1c8f13" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/ReifiedLemmas.olean", + "sha256": "6c4ff9969869b0ba86b098d8bb95e2caeb88bc61426a7659ec2d1e80fd3f0496" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/Reify.olean", + "sha256": "65491bfa39b0698c310a8a8878cb01596e4616627416f40ae45e0fd622709e54" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVDecide/SatAtBVLogical.olean", + "sha256": "980164e9c31b64c83e46c01e78ec64630226c39920485143be4e40b859da161e" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.BVTrace": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/BVTrace.olean", + "sha256": "1996eabaa1c3f4916f484b35c39a4bcc270e9a46b9592b9b6e63b28b95acd5fa" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.LRAT": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/LRAT.olean", + "sha256": "a9777f4dc66bea0b57d7a9b2b750ce78d906d0bfa930cfd0b0281b5920467aba" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize.olean", + "sha256": "74af1f202de4c2fbe0aeab11e5bf05bb495342404062a0db74097f35b666b423" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AC.olean", + "sha256": "b24d88b0fbed216dfdaf934f8653d37291af5e1288d5485736bfd75deb10c182" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/AndFlatten.olean", + "sha256": "df98785c5e1b7e6e5114b0c1a90760ee11277742f3ec36f4834cafa51fc567a1" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ApplyControlFlow.olean", + "sha256": "8abb3b652bdd68df142259c20a7e85e26fc1c7f1ad5d1111ad8574cb7251323f" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Basic.olean", + "sha256": "07d568115382b9a9832437443a5665dd9ab05ebaaa6e613e2336083a18a5f843" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/EmbeddedConstraint.olean", + "sha256": "5a338a9edef0294acf2e8ee6923e0b02965595576fff7b130ced1626af66fdc6" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Enums.olean", + "sha256": "b999e4ddc8d0d2077c56af1f1a000fe53fa3e81c97b47c5bf48d4dfbc243cfd8" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/IntToBitVec.olean", + "sha256": "82d5b4e7c2ec35f28230ce0ea464680a38a439260496c2ecc624130c7177a14b" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Rewrite.olean", + "sha256": "bf6a3b70f9fedd5c42111b2afd4a947fc8085947342a1123073f65558540f436" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/ShortCircuit.olean", + "sha256": "a6588498df687fb758121463de9ae1040535ceb6c317715218669e061b05a088" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Simproc.olean", + "sha256": "87a5d15e22301b1a7c50064a06e11cae3e2b3b7ae8f4db72437bd5dea8d09077" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/Structures.olean", + "sha256": "7e18d7f9c1daff3a8b7eeca9765a3933fb244156bb5a238b03fd3d6667146a57" + }, + "Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/Frontend/Normalize/TypeAnalysis.olean", + "sha256": "a60b02e2a039134f7b533c911f7beed13d84812b6062b9f19185630e282912ce" + }, + "Lean.Elab.Tactic.BVDecide.LRAT": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT.olean", + "sha256": "2265489cbaad7404d01662160bc49c6036f770a8a23257ad912587b3c94c992f" + }, + "Lean.Elab.Tactic.BVDecide.LRAT.Trim": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BVDecide/LRAT/Trim.olean", + "sha256": "496f7c3dd081cece59390406bd9ca3d7b8280aa923e7d50e764867b0f3895546" + }, + "Lean.Elab.Tactic.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Basic.olean", + "sha256": "b7c0301d5608f70cc3b200a6c051173f74f9feffb83b1e7993b680a28e4dec4f" + }, + "Lean.Elab.Tactic.BoolToPropSimps": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BoolToPropSimps.olean", + "sha256": "d5e4ca3bfddbd7e2538e80f41161ea63be1ed1eec0bd637d064b11e4478c6737" + }, + "Lean.Elab.Tactic.BuiltinTactic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/BuiltinTactic.olean", + "sha256": "72d1c873432fe4f9dff0aa9a83056dd824703fe0faa8593f5e2a186335e12c21" + }, + "Lean.Elab.Tactic.Calc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Calc.olean", + "sha256": "b22ed20091a768b533dbf3cb92b94e3dea2a22cc70e6e013bc0e932c0a92d721" + }, + "Lean.Elab.Tactic.Change": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Change.olean", + "sha256": "c3d3fe5640183577289c4f0c7dfc9a5e82953709dc9f81ab3305a64f2c972f83" + }, + "Lean.Elab.Tactic.Classical": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Classical.olean", + "sha256": "dd96a577b5982c72e7c2f9cce5cf089a933ecc0614589fdd0d741b39c721b9d5" + }, + "Lean.Elab.Tactic.Config": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Config.olean", + "sha256": "18f6104d6c843452c5742a476d16659ee05d21021eefd2d72d3a9be27a4c0009" + }, + "Lean.Elab.Tactic.Congr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Congr.olean", + "sha256": "c2cbd01a116eeab3bc6d560d5b5e812915eda68ddd4fd972444df910e1ce6f07" + }, + "Lean.Elab.Tactic.Conv": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv.olean", + "sha256": "9e13c60aac36d8d5ab077fb214f9749bd03e689fd47b66fdeb65f54b42e61fcc" + }, + "Lean.Elab.Tactic.Conv.Basic": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Basic.olean", + "sha256": "36acbc413b0baecc6d1db794fdf6e9afdc393dbb0a43b4d132ed06e80af8987d" + }, + "Lean.Elab.Tactic.Conv.Change": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Change.olean", + "sha256": "d6645dd05e52922f9008332cc16dffd5e475221c524292446010a022f7180efc" + }, + "Lean.Elab.Tactic.Conv.Congr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Congr.olean", + "sha256": "b5c476623ea1b622800815da4f1d2b769643c1bdb0c4c7524bed4851276413bf" + }, + "Lean.Elab.Tactic.Conv.Delta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Delta.olean", + "sha256": "6953c32bc540eaaa79b2221b31a9eecf9d86fc5ce46e69cc8f0ad6a3f1902419" + }, + "Lean.Elab.Tactic.Conv.Pattern": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Pattern.olean", + "sha256": "8fae7911921a66098eba444b60030314b9f52f202353e586205472afdd07c068" + }, + "Lean.Elab.Tactic.Conv.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Rewrite.olean", + "sha256": "492425f642d76075007692216a7368c533ebb8e0def54334a7fbbe849baed77e" + }, + "Lean.Elab.Tactic.Conv.Simp": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Simp.olean", + "sha256": "914f50cab77467b8faa5d21c14664fa552ca6c69339ecfc798150b48b37d3272" + }, + "Lean.Elab.Tactic.Conv.Unfold": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Conv/Unfold.olean", + "sha256": "a893adf2f22bb0bae62f47d5c4b30ae3bcedc121a7ab747398e5f780262be63b" + }, + "Lean.Elab.Tactic.Delta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Delta.olean", + "sha256": "c80c125f4b2c716c5a140a18b02d0c2c2add3d4a4e749e9774b6e36a6e6d726f" + }, + "Lean.Elab.Tactic.DiscrTreeKey": { + "relative_path": "lib/lean/Lean/Elab/Tactic/DiscrTreeKey.olean", + "sha256": "90696c26393713d01d2efefc91713c23de2d2b9ea842dcd5b0be7602ef2d2d51" + }, + "Lean.Elab.Tactic.Doc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Doc.olean", + "sha256": "f7466ce696081046b90259ed10bfce6647f3e31b5b624987527aace912d6836d" + }, + "Lean.Elab.Tactic.ElabTerm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ElabTerm.olean", + "sha256": "c93025d17c141b6a8172abd80d25fd2083f061aea574ed5b5fb85752f32ef39f" + }, + "Lean.Elab.Tactic.ExposeNames": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ExposeNames.olean", + "sha256": "b5083e8a6aa77fd5d2aa2a73cdd0777e2f2e7018e6fe73f017e31220f136ab36" + }, + "Lean.Elab.Tactic.Ext": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Ext.olean", + "sha256": "41b7e7b7c44fec4c25d21754296cb2c63b901f6ec840e4d68fd5f73c0d27bf16" + }, + "Lean.Elab.Tactic.FalseOrByContra": { + "relative_path": "lib/lean/Lean/Elab/Tactic/FalseOrByContra.olean", + "sha256": "e9c4388c61790ea040377ad4794524db4078ac279c84bfda4873f93a9e286e72" + }, + "Lean.Elab.Tactic.Generalize": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Generalize.olean", + "sha256": "f508333fab3030de8fd72a5d3e269baab671664d61c9a4f9d838a86a49945533" + }, + "Lean.Elab.Tactic.Grind": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Grind.olean", + "sha256": "08be616fb5e448a7109ff7ea58dd14de1902dbe5e8df8a873ba79e4e34523c74" + }, + "Lean.Elab.Tactic.Guard": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Guard.olean", + "sha256": "f853574192c0c04c7a6fd40a04e71966bea87d164c2dfd58066119d2b273cc53" + }, + "Lean.Elab.Tactic.Induction": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Induction.olean", + "sha256": "cb71a7fa68a672ebb2f3bfa1643a418d82d0c545d5d5b2e992a46695a14f491e" + }, + "Lean.Elab.Tactic.Injection": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Injection.olean", + "sha256": "a21d54f553d5ecbeb0bb2983f5d37040186dca297ccaa8fe5457c15333f55662" + }, + "Lean.Elab.Tactic.LibrarySearch": { + "relative_path": "lib/lean/Lean/Elab/Tactic/LibrarySearch.olean", + "sha256": "aa4345322004c2831a322f51f0b28e6c846017c08fe3dc2861c6497dca393055" + }, + "Lean.Elab.Tactic.Location": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Location.olean", + "sha256": "1098b443df5ebadfee2fc68faf7038dabacb07541f38639ac31be344e1391bdf" + }, + "Lean.Elab.Tactic.Match": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Match.olean", + "sha256": "63335a98a881cb68e20bffdb30fa3771ecb62823849ae21bb31426adc5aaccc9" + }, + "Lean.Elab.Tactic.Meta": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Meta.olean", + "sha256": "567713a64ca01f5b9ab6c091ed9cd25f3ae811dd96d379690824c1048238a466" + }, + "Lean.Elab.Tactic.Monotonicity": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Monotonicity.olean", + "sha256": "fa4e39f81c52c25684740ec8b522ddb1e75e2a770da086aa498542a0254bb3ab" + }, + "Lean.Elab.Tactic.NormCast": { + "relative_path": "lib/lean/Lean/Elab/Tactic/NormCast.olean", + "sha256": "8edb153050da1e5977675c29d0faa559f8ede051b8384ea592aa05c9c892e10d" + }, + "Lean.Elab.Tactic.Omega": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega.olean", + "sha256": "4b2613345cb64b57ac4f8a0183f43e1afe4138ef8eaed2158e9d053107262491" + }, + "Lean.Elab.Tactic.Omega.Core": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/Core.olean", + "sha256": "f133556a6f4675885619fb6fb25a670fb3afce9a98b14ab0b31d89b5ecb6a2ea" + }, + "Lean.Elab.Tactic.Omega.Frontend": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/Frontend.olean", + "sha256": "03c91bedf7a6187e5e74519f66bda5d6e18552fa291f950f9d3310613d99013d" + }, + "Lean.Elab.Tactic.Omega.MinNatAbs": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/MinNatAbs.olean", + "sha256": "5fc208621322f361f7d3e75f63418aec5d8851c6b75bd6a39e922f0d8b0ba191" + }, + "Lean.Elab.Tactic.Omega.OmegaM": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Omega/OmegaM.olean", + "sha256": "99de653d54903f4599f5883f5fc1fb078ca24550ff5656b10ff227552f8af2b8" + }, + "Lean.Elab.Tactic.RCases": { + "relative_path": "lib/lean/Lean/Elab/Tactic/RCases.olean", + "sha256": "cb15fe0c2bb64023666293bb14cd157c6d756fa59dc0e8aec39b8b6f28968731" + }, + "Lean.Elab.Tactic.Repeat": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Repeat.olean", + "sha256": "5f1389c2109470e537d2486218baea2f9b69842ad86150b3c78d919b589020b5" + }, + "Lean.Elab.Tactic.Rewrite": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rewrite.olean", + "sha256": "332ab3fca4f37076f27bbdf57e5d614923d0d1048e1e325c56a4ae5f78a3bdf0" + }, + "Lean.Elab.Tactic.Rewrites": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rewrites.olean", + "sha256": "510a661f998f5c279f14b60fec476368bb1ed9a003c3c4753c6caa2d88c349c1" + }, + "Lean.Elab.Tactic.Rfl": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Rfl.olean", + "sha256": "debc83c10ccd0f91e6944c7f2409f0390766d3c90195d90b9bc3e379a5528ebf" + }, + "Lean.Elab.Tactic.ShowTerm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/ShowTerm.olean", + "sha256": "1a58d3dab98f084c1e30cd1ad363f9dcce132dd3563f7f1b3a10ea4e5b982b31" + }, + "Lean.Elab.Tactic.Simp": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simp.olean", + "sha256": "7c99ed2d7fd716baaff7454c392df88cc0ed62c7717f7a3df5fde04e69b76a24" + }, + "Lean.Elab.Tactic.SimpArith": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SimpArith.olean", + "sha256": "947ba620a7f12f3039363f12e8b609b1532421e0a15de3091c7476f38200cd19" + }, + "Lean.Elab.Tactic.SimpTrace": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SimpTrace.olean", + "sha256": "71135cbb56c87c91b4654fc258dfee3c56abd5659705c75502c97bc4098f2b1b" + }, + "Lean.Elab.Tactic.Simpa": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simpa.olean", + "sha256": "ecf16470fb1388ccc43ef450a7cc9a3bea94c691d800f90b909817b14d277db2" + }, + "Lean.Elab.Tactic.Simproc": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Simproc.olean", + "sha256": "67adccf068a87d29a3658b600ea8d395ad93eb34518f94930e273e9dd227a998" + }, + "Lean.Elab.Tactic.SolveByElim": { + "relative_path": "lib/lean/Lean/Elab/Tactic/SolveByElim.olean", + "sha256": "4b83ef14834e716e40e4225b7fc6e6e0be6a4fac044490fcdcea8684314e9890" + }, + "Lean.Elab.Tactic.Split": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Split.olean", + "sha256": "1d662891823face6895782eadc704cb76813e37325f70c681ac2e481219d06a2" + }, + "Lean.Elab.Tactic.Symm": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Symm.olean", + "sha256": "03415c9848515aa79dac3634eda5a005dbe2d662168206bdae2d4aeebbc5c670" + }, + "Lean.Elab.Tactic.TreeTacAttr": { + "relative_path": "lib/lean/Lean/Elab/Tactic/TreeTacAttr.olean", + "sha256": "317645bd9832a71c3d83747c516f0084c6f778a2f01a9f1725396a9ee99f9405" + }, + "Lean.Elab.Tactic.Try": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Try.olean", + "sha256": "e06377c171ef6f8d33196b70e2c138672956f14a668924bd8dbba6ede2325966" + }, + "Lean.Elab.Tactic.Unfold": { + "relative_path": "lib/lean/Lean/Elab/Tactic/Unfold.olean", + "sha256": "a096a399bfc253d22fceda76ad31bfe1c32923302d3fc517e0736b8c2e29fb74" + }, + "Lean.Elab.Term": { + "relative_path": "lib/lean/Lean/Elab/Term.olean", + "sha256": "f96c6c457c651da44cb9aed7d0af002589a9dd635ec492029254eeb679e85703" + }, + "Lean.Elab.Time": { + "relative_path": "lib/lean/Lean/Elab/Time.olean", + "sha256": "6b9da11286e522cb54d1759a5e4f93f50dc49b537c785daca8362c216c0141ef" + }, + "Lean.Elab.Util": { + "relative_path": "lib/lean/Lean/Elab/Util.olean", + "sha256": "d17dd23eb1ff8167dfe81c18ca2d79eb2aa863ad660be8f91057f952ac60ec2e" + }, + "Lean.Environment": { + "relative_path": "lib/lean/Lean/Environment.olean", + "sha256": "f65e86963b340104aec0500759c0221ce805877552a74a222444517efea4f327" + }, + "Lean.Exception": { + "relative_path": "lib/lean/Lean/Exception.olean", + "sha256": "348180c98395bf5936594ac1a00295baf447f096c9d55de58f1ad28b80ff532e" + }, + "Lean.Expr": { + "relative_path": "lib/lean/Lean/Expr.olean", + "sha256": "b109611aabeef2b002d78f15e7d05934c7af1dc5739a2aadde294f1417e828ee" + }, + "Lean.HeadIndex": { + "relative_path": "lib/lean/Lean/HeadIndex.olean", + "sha256": "a184c76eed310d6d6e6a855f50d25e694c10a0f3be2c8c2e01aafa23113aa817" + }, + "Lean.Hygiene": { + "relative_path": "lib/lean/Lean/Hygiene.olean", + "sha256": "f8122bf1f713f1514bdbdeb3cee8090c7d524255998bdb3f077a26fbf9e33bb9" + }, + "Lean.ImportingFlag": { + "relative_path": "lib/lean/Lean/ImportingFlag.olean", + "sha256": "ce6df3c54e60e9f9741b44b6c787667ff8edea324d61df14d97c3c6be2d4a314" + }, + "Lean.InternalExceptionId": { + "relative_path": "lib/lean/Lean/InternalExceptionId.olean", + "sha256": "314fb4e2c9c8a74700fb4ba28ff8996102d6960b101dc5e8ea058928b76671e7" + }, + "Lean.KeyedDeclsAttribute": { + "relative_path": "lib/lean/Lean/KeyedDeclsAttribute.olean", + "sha256": "6965a89059d292ffd11ede6d477a9895b5742df767da760a63958167e08709da" + }, + "Lean.LabelAttribute": { + "relative_path": "lib/lean/Lean/LabelAttribute.olean", + "sha256": "f6357ee28525c80e0e1e50f30d6abc8e9c212faf66266638907f7734baf8c4a9" + }, + "Lean.Language.Basic": { + "relative_path": "lib/lean/Lean/Language/Basic.olean", + "sha256": "116198598d0a090a3f8c1ac2df76863e2c130506768f741dd96c657b4f28f62c" + }, + "Lean.Language.Lean": { + "relative_path": "lib/lean/Lean/Language/Lean.olean", + "sha256": "ec21c3356101da99d833c4dbe27da14a587b238e0dcfead17dd1954358b4e730" + }, + "Lean.Language.Lean.Types": { + "relative_path": "lib/lean/Lean/Language/Lean/Types.olean", + "sha256": "e41961572ed5c15c53ca9829747714c5157397631bd11805558205cc21d2c300" + }, + "Lean.Language.Util": { + "relative_path": "lib/lean/Lean/Language/Util.olean", + "sha256": "7a02b960729bb110fe366fa1cfc75e7974ed6c4e984488b3d41c3701bae6d021" + }, + "Lean.Level": { + "relative_path": "lib/lean/Lean/Level.olean", + "sha256": "b0a2bdff71bacb1202f1c2b034fbfcaef3a928cb8508fe31751111872644168f" + }, + "Lean.Linter": { + "relative_path": "lib/lean/Lean/Linter.olean", + "sha256": "0ad71e4ddd414f842de88817808764b12d0dbc35fb0250beb219a6aac4d105e1" + }, + "Lean.Linter.Basic": { + "relative_path": "lib/lean/Lean/Linter/Basic.olean", + "sha256": "f15c89429080e69fa9ce443c7ab1462990d6cfb127c38ce3cc2e9c3150eaf319" + }, + "Lean.Linter.Builtin": { + "relative_path": "lib/lean/Lean/Linter/Builtin.olean", + "sha256": "65bcaf73e26b3b782cc55118edee888ef878f6eb321ef6c89ba6344c8c828727" + }, + "Lean.Linter.ConstructorAsVariable": { + "relative_path": "lib/lean/Lean/Linter/ConstructorAsVariable.olean", + "sha256": "d23b80487fc0b4ffb80cfe74517b2b44c317f857288c45e9573fa5595e7c0b76" + }, + "Lean.Linter.Deprecated": { + "relative_path": "lib/lean/Lean/Linter/Deprecated.olean", + "sha256": "ee83025c6435587e7822db2d39a94f7192a3be4828e76712936a6d687c1654b5" + }, + "Lean.Linter.List": { + "relative_path": "lib/lean/Lean/Linter/List.olean", + "sha256": "72b11db674930f01297e66d6fe9168b2711db7ed0f3a8062014bbe5628431447" + }, + "Lean.Linter.MissingDocs": { + "relative_path": "lib/lean/Lean/Linter/MissingDocs.olean", + "sha256": "89abae84ca6318a0f514ad6ab9164a28db6a35afe87b77303fca87d4a725dcff" + }, + "Lean.Linter.Omit": { + "relative_path": "lib/lean/Lean/Linter/Omit.olean", + "sha256": "8e0d622b1be4f992d2355f4ec978f33899e36c6caaeca50b3394326f74cab35e" + }, + "Lean.Linter.UnusedVariables": { + "relative_path": "lib/lean/Lean/Linter/UnusedVariables.olean", + "sha256": "d5bae599fc34fe808ea8d61cefa05405ae98d97184c208c92cbe883e9dfc20ea" + }, + "Lean.Linter.Util": { + "relative_path": "lib/lean/Lean/Linter/Util.olean", + "sha256": "e983ec22a68494993b52d4bc349e4fd8ed0e73c11a7236cdcfd14c58058da4a3" + }, + "Lean.LoadDynlib": { + "relative_path": "lib/lean/Lean/LoadDynlib.olean", + "sha256": "7bbb1aa363e257a2de2975ac17e31bbf58d4d4cd328d592710e6a718e71496b4" + }, + "Lean.LocalContext": { + "relative_path": "lib/lean/Lean/LocalContext.olean", + "sha256": "1b6191a3341ed46fa6b8dbcd3f24e245ae1b8c6ab39d080f2ff5cecc2e26250e" + }, + "Lean.Log": { + "relative_path": "lib/lean/Lean/Log.olean", + "sha256": "032fbe05a131072d1b0779947f012b10687e42ee07019d7ea29fff2d100e709f" + }, + "Lean.Message": { + "relative_path": "lib/lean/Lean/Message.olean", + "sha256": "c36f1a3906e9d18d564572f38bd3b687db02b21897db07f6470025ae522ea73f" + }, + "Lean.Meta": { + "relative_path": "lib/lean/Lean/Meta.olean", + "sha256": "206cf2fcc5bef1191f930198dfb2b0cd2042bf96f47c40faaf98cc105e137809" + }, + "Lean.Meta.ACLt": { + "relative_path": "lib/lean/Lean/Meta/ACLt.olean", + "sha256": "da1c2e3e8f486413a1fee34f34a938179cfdd72342ced421b82d230af508788d" + }, + "Lean.Meta.AbstractMVars": { + "relative_path": "lib/lean/Lean/Meta/AbstractMVars.olean", + "sha256": "a3e0a762ba6c0f8852c50c993c98208b5ce37e53cd374530f2b6f2cd119a4b34" + }, + "Lean.Meta.AbstractNestedProofs": { + "relative_path": "lib/lean/Lean/Meta/AbstractNestedProofs.olean", + "sha256": "fc0a2ed4ddd5bfc2c16958b017a88d2751126cec190d0eeb80a777c6825d2fa4" + }, + "Lean.Meta.AppBuilder": { + "relative_path": "lib/lean/Lean/Meta/AppBuilder.olean", + "sha256": "7cd2bf696029e7211829c3c8152df760b2e4695304ca409a76775c196ae56549" + }, + "Lean.Meta.ArgsPacker": { + "relative_path": "lib/lean/Lean/Meta/ArgsPacker.olean", + "sha256": "a7f9e66a5cc17f1ce38ec0b459f0ca4ab7b8a4273762e2c05b35ad57626b539e" + }, + "Lean.Meta.ArgsPacker.Basic": { + "relative_path": "lib/lean/Lean/Meta/ArgsPacker/Basic.olean", + "sha256": "6d74b8180f4fbc25df85bd09ae4ff159591fd5b7ec68dc02b798cb70a79112e4" + }, + "Lean.Meta.Basic": { + "relative_path": "lib/lean/Lean/Meta/Basic.olean", + "sha256": "f12db9629e0a571e3774816fec958dbc481f79f7b8a2c4c4bbd5208e12ccc24d" + }, + "Lean.Meta.BinderNameHint": { + "relative_path": "lib/lean/Lean/Meta/BinderNameHint.olean", + "sha256": "0d948af6513e8326ed601ea521ff00b87dd6d019bd5b60bf40860a7e5f5905f8" + }, + "Lean.Meta.Canonicalizer": { + "relative_path": "lib/lean/Lean/Meta/Canonicalizer.olean", + "sha256": "9262985c3ac4e2f8b7207fdeb2bf7fbab1db0dc6581b85a26c2cc27965ec43ee" + }, + "Lean.Meta.Check": { + "relative_path": "lib/lean/Lean/Meta/Check.olean", + "sha256": "502569420ced0ae9c7c72746fe0a34b7340279a7852e922a9b8ec5c183b97235" + }, + "Lean.Meta.CheckTactic": { + "relative_path": "lib/lean/Lean/Meta/CheckTactic.olean", + "sha256": "30e7beace22600567ab8f275bda3c48c83d8d80a14a654a0f723e125eef28377" + }, + "Lean.Meta.Closure": { + "relative_path": "lib/lean/Lean/Meta/Closure.olean", + "sha256": "092e59d5c44691e648c7e6b4151d18030b17a703b124d134c3e233d952c90058" + }, + "Lean.Meta.Coe": { + "relative_path": "lib/lean/Lean/Meta/Coe.olean", + "sha256": "72cd74ba7424353c0c7acb6cd05dd27d7f27d07fa8936fd54a96141d22d7671c" + }, + "Lean.Meta.CoeAttr": { + "relative_path": "lib/lean/Lean/Meta/CoeAttr.olean", + "sha256": "16993537a5507a03ac41462d5a54030993c6e9303353d59270b5df4762af31a9" + }, + "Lean.Meta.CollectFVars": { + "relative_path": "lib/lean/Lean/Meta/CollectFVars.olean", + "sha256": "d46e2325951ddff2997f5d37f9b688edc09d75d360711d9ae51415b9ed6a6dde" + }, + "Lean.Meta.CollectMVars": { + "relative_path": "lib/lean/Lean/Meta/CollectMVars.olean", + "sha256": "b2846166247972427c1225d20859aaa46fe676c321f3e4b8943ae064d9259b1e" + }, + "Lean.Meta.CompletionName": { + "relative_path": "lib/lean/Lean/Meta/CompletionName.olean", + "sha256": "2af094a0fd892457002a8b311a318ebb1d3b347f694fa5bd3c4a710bb3d0f5ae" + }, + "Lean.Meta.CongrTheorems": { + "relative_path": "lib/lean/Lean/Meta/CongrTheorems.olean", + "sha256": "ae1d73989795378f2db8d6725484544fbf700d26861669e26ed071fb3d5aa774" + }, + "Lean.Meta.Constructions": { + "relative_path": "lib/lean/Lean/Meta/Constructions.olean", + "sha256": "bd42abcf4b09dd47d7b07f34bce755794a76f242171f34720060f743c91d7e7b" + }, + "Lean.Meta.Constructions.BRecOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/BRecOn.olean", + "sha256": "91bb12647e28558fa3562e3ef84df4f40044d7a68fa2d0a0092f9a8b52852111" + }, + "Lean.Meta.Constructions.CasesOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/CasesOn.olean", + "sha256": "827e45d478f86cf087cc904ee3c3021343ac62fcf500ced79f733a631a72c4c8" + }, + "Lean.Meta.Constructions.NoConfusion": { + "relative_path": "lib/lean/Lean/Meta/Constructions/NoConfusion.olean", + "sha256": "4428b1ecf05f66c20cbfd068963aa5778bb1dc417f84e24a99010e93618d9268" + }, + "Lean.Meta.Constructions.RecOn": { + "relative_path": "lib/lean/Lean/Meta/Constructions/RecOn.olean", + "sha256": "08d7bf9cce44bfb9da0382e248b7232936f8e9b4e04d9f01272257e2c3e93e58" + }, + "Lean.Meta.CtorRecognizer": { + "relative_path": "lib/lean/Lean/Meta/CtorRecognizer.olean", + "sha256": "dc104bc4378dcd0427c4d67654ad199261907c9434bd5e59548f1960b7918c57" + }, + "Lean.Meta.DecLevel": { + "relative_path": "lib/lean/Lean/Meta/DecLevel.olean", + "sha256": "a2eed500e45408ea6f1531256849e4e47d7cb3ccdb8621c3a44769f45d23d37a" + }, + "Lean.Meta.Diagnostics": { + "relative_path": "lib/lean/Lean/Meta/Diagnostics.olean", + "sha256": "e64e866f33cb55305ffb4588647652a034aa08108bda8e49ba7b87f5b5c09dc8" + }, + "Lean.Meta.DiscrTree": { + "relative_path": "lib/lean/Lean/Meta/DiscrTree.olean", + "sha256": "a285696f66951a789b2d325baec39c256f247a40c4c442dcc5b5c631185a590e" + }, + "Lean.Meta.DiscrTreeTypes": { + "relative_path": "lib/lean/Lean/Meta/DiscrTreeTypes.olean", + "sha256": "35157be01b47d45c6ccfb978fe042752d42b919a13c2c59df749d78df28513d1" + }, + "Lean.Meta.Eqns": { + "relative_path": "lib/lean/Lean/Meta/Eqns.olean", + "sha256": "61d27ab1c2d1ea8db95324a4612e717c5e0a8c9fd7e6bb7cb13c928f4cc63703" + }, + "Lean.Meta.Eval": { + "relative_path": "lib/lean/Lean/Meta/Eval.olean", + "sha256": "8451e897121ce84e0e443be0ad1de1177143a1960c634d31c1b373d0ec30e5a1" + }, + "Lean.Meta.ExprDefEq": { + "relative_path": "lib/lean/Lean/Meta/ExprDefEq.olean", + "sha256": "ac84eb17f56223f5cf46553327dbfa0279b437802957cb292551c592b449a502" + }, + "Lean.Meta.ExprLens": { + "relative_path": "lib/lean/Lean/Meta/ExprLens.olean", + "sha256": "b8ac1969551532255d7a2b0223a00c65bf0bc468f90e7aba64fd6c697db6bb5b" + }, + "Lean.Meta.ExprTraverse": { + "relative_path": "lib/lean/Lean/Meta/ExprTraverse.olean", + "sha256": "b0cf3399e8837d8019f29b7e42b94028b42c6fcf40bca98a498ee9a3641ff948" + }, + "Lean.Meta.ForEachExpr": { + "relative_path": "lib/lean/Lean/Meta/ForEachExpr.olean", + "sha256": "6f2ade443619ee7d60f73bc62b4e1efd7372418d4f5b28b8b8233ac2c28ce1a9" + }, + "Lean.Meta.FunInfo": { + "relative_path": "lib/lean/Lean/Meta/FunInfo.olean", + "sha256": "b855ba9c1d30fec86c39339dd3cbfef0cfcdcdb7e78c25ad04103b37abc1a9ca" + }, + "Lean.Meta.GeneralizeTelescope": { + "relative_path": "lib/lean/Lean/Meta/GeneralizeTelescope.olean", + "sha256": "5ee0c1c92441c434c043593778ed21e47badeadce84e78a99682cedfad480372" + }, + "Lean.Meta.GeneralizeVars": { + "relative_path": "lib/lean/Lean/Meta/GeneralizeVars.olean", + "sha256": "796bc3bc0a297f547b39413e39611eb8829e642e7f44da2f4cea6d0d4ef56265" + }, + "Lean.Meta.GetUnfoldableConst": { + "relative_path": "lib/lean/Lean/Meta/GetUnfoldableConst.olean", + "sha256": "2ea066ddcc64d26c2d70e77bd3c7b015c8ee3f755d10187352eb155962d91427" + }, + "Lean.Meta.GlobalInstances": { + "relative_path": "lib/lean/Lean/Meta/GlobalInstances.olean", + "sha256": "8265fb3b50c621767dc77e38921e2fe7360694ce5b7ac3e24bdc67e0c3946f57" + }, + "Lean.Meta.IndPredBelow": { + "relative_path": "lib/lean/Lean/Meta/IndPredBelow.olean", + "sha256": "c93d1f840670b555e569ac9d262d1f41decd51f3d134d54ff4e53bb542e9cb58" + }, + "Lean.Meta.Inductive": { + "relative_path": "lib/lean/Lean/Meta/Inductive.olean", + "sha256": "cbd800e5e3644765969dc14c322b700120c9dd2c3db0d499e72c13f607fb29aa" + }, + "Lean.Meta.InferType": { + "relative_path": "lib/lean/Lean/Meta/InferType.olean", + "sha256": "a9e3c61dd6022e6864ca3416c5567360975a3781076d8dedd4b93507bfe12703" + }, + "Lean.Meta.Injective": { + "relative_path": "lib/lean/Lean/Meta/Injective.olean", + "sha256": "022f6530d2761e0fd32e4a8a1d390badfe3bbf852a92bebf2269b4cacf93ac9d" + }, + "Lean.Meta.Instances": { + "relative_path": "lib/lean/Lean/Meta/Instances.olean", + "sha256": "fcc360ddf8ee95db9d62118b0c262c6695b38251dcd96f086fee6c5195966516" + }, + "Lean.Meta.IntInstTesters": { + "relative_path": "lib/lean/Lean/Meta/IntInstTesters.olean", + "sha256": "33498b0c4626bd28ce45b7a3f7996aaee28f3cea1e8a9a6cbbe6fdeb24619209" + }, + "Lean.Meta.Iterator": { + "relative_path": "lib/lean/Lean/Meta/Iterator.olean", + "sha256": "101d4d68efea3a23fbd0dc5f16e63ff16c65b391862a09feee2f7930dc671703" + }, + "Lean.Meta.KAbstract": { + "relative_path": "lib/lean/Lean/Meta/KAbstract.olean", + "sha256": "1ff48dc21dc7daa5701ec93ebf8dea8e853eb9c76c7f08df3c047b2e364c0fd6" + }, + "Lean.Meta.KExprMap": { + "relative_path": "lib/lean/Lean/Meta/KExprMap.olean", + "sha256": "a61c80321e32eb1ac29c70f05a557bc9a950b6a65d0503e94031cd21c697f84c" + }, + "Lean.Meta.LazyDiscrTree": { + "relative_path": "lib/lean/Lean/Meta/LazyDiscrTree.olean", + "sha256": "0e52ab3e1bba285513237aa0ad00ebbeca9f6f2de5e6ffed01aa0aff4ebce915" + }, + "Lean.Meta.LevelDefEq": { + "relative_path": "lib/lean/Lean/Meta/LevelDefEq.olean", + "sha256": "039d6b9b7f252227092b329102542df7d9c09edceb1aefa45fc712078c65c5d7" + }, + "Lean.Meta.LitValues": { + "relative_path": "lib/lean/Lean/Meta/LitValues.olean", + "sha256": "fc41c863bde3e203433870eb601640349cb7855f816bdebbde1a2a204c9bdace" + }, + "Lean.Meta.Match": { + "relative_path": "lib/lean/Lean/Meta/Match.olean", + "sha256": "548ceb8925264b3c53204550bfea3548b9e73b11f0124d9a7f4343aed053ad9d" + }, + "Lean.Meta.Match.Basic": { + "relative_path": "lib/lean/Lean/Meta/Match/Basic.olean", + "sha256": "ad8f2a68e4366a7c0c5939323446515ac428595f1da113a506bf12039fb16442" + }, + "Lean.Meta.Match.CaseArraySizes": { + "relative_path": "lib/lean/Lean/Meta/Match/CaseArraySizes.olean", + "sha256": "e221018a693db011a0414635b7b68c8b8388950b2c2d4731ce41a6a5576a1d57" + }, + "Lean.Meta.Match.CaseValues": { + "relative_path": "lib/lean/Lean/Meta/Match/CaseValues.olean", + "sha256": "537ddad23a87967f7088967a2a347eb108cc36e2d4e4d9ffb0a8396d65da88df" + }, + "Lean.Meta.Match.Match": { + "relative_path": "lib/lean/Lean/Meta/Match/Match.olean", + "sha256": "2e73790b9ba9e908afaec1f9636dbe6f8ca5388dd11caa89f03e0e9579138516" + }, + "Lean.Meta.Match.MatchEqs": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchEqs.olean", + "sha256": "3e0c930d82985234eaf74ec74fb3bc7dffc959608f43bd38ac33a884500315a7" + }, + "Lean.Meta.Match.MatchEqsExt": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchEqsExt.olean", + "sha256": "bfe53903e9962eeede9b619f0ba796108662c4945af59198a5834799589b1d68" + }, + "Lean.Meta.Match.MatchPatternAttr": { + "relative_path": "lib/lean/Lean/Meta/Match/MatchPatternAttr.olean", + "sha256": "6c7c6f96c64e483fc2864cb94a9e2f1fe2570e04660100eec221bb0511e5684a" + }, + "Lean.Meta.Match.MatcherApp": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp.olean", + "sha256": "e2ed9a86cbc2817d5fa9a023ef571b6b077e2626b8c4e6799fc4f9c31bfa9520" + }, + "Lean.Meta.Match.MatcherApp.Basic": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp/Basic.olean", + "sha256": "cd872e793052ffcbbdaed58e949e35afe056e7b7177b49c70d3c5fd6cb269825" + }, + "Lean.Meta.Match.MatcherApp.Transform": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherApp/Transform.olean", + "sha256": "df0e6ddff62c7c9906a8704ed1338b841299acbdb0c4894eea4dd9f253824cb4" + }, + "Lean.Meta.Match.MatcherInfo": { + "relative_path": "lib/lean/Lean/Meta/Match/MatcherInfo.olean", + "sha256": "83151f202d8e0d8b58fd86326458d33e3f8f060038aaccc7909d07cfb8c4a5c6" + }, + "Lean.Meta.Match.Value": { + "relative_path": "lib/lean/Lean/Meta/Match/Value.olean", + "sha256": "0c40eecc0e0da4ec9cc2eec21580f3493911fb56c753dab89c51327bfb64551a" + }, + "Lean.Meta.MatchUtil": { + "relative_path": "lib/lean/Lean/Meta/MatchUtil.olean", + "sha256": "5ff0623e662f1b1ba9035709de58345cf18417f05bf3580448d963471d4f1f93" + }, + "Lean.Meta.NatInstTesters": { + "relative_path": "lib/lean/Lean/Meta/NatInstTesters.olean", + "sha256": "3a54ef6c555c2304cd894a59b7519e7cf1138c5082ea7c6b541d2558f68d729e" + }, + "Lean.Meta.Offset": { + "relative_path": "lib/lean/Lean/Meta/Offset.olean", + "sha256": "e9bccfe44f2cb64ac53bdb8d4391720754a15706c982a7f4ee8b3c19b2001ed2" + }, + "Lean.Meta.PPGoal": { + "relative_path": "lib/lean/Lean/Meta/PPGoal.olean", + "sha256": "1ff4e4b1dd870a3fc09b5b9bd5bdf20dd4a0263d2a652b4d4d3461495e7d713b" + }, + "Lean.Meta.PProdN": { + "relative_path": "lib/lean/Lean/Meta/PProdN.olean", + "sha256": "d8b86b781fa66571ceb5087c16cac87cd37beb344e9134818bff6e4003f2a6b4" + }, + "Lean.Meta.RecursorInfo": { + "relative_path": "lib/lean/Lean/Meta/RecursorInfo.olean", + "sha256": "c7deca642d62ab08712aa143b716f781872a5e421470246d94bc9fb7dd862b47" + }, + "Lean.Meta.Reduce": { + "relative_path": "lib/lean/Lean/Meta/Reduce.olean", + "sha256": "6ae0326d4d14d180af14176daf097cf236bd4347a95d87b93a7e5996d1ae95ea" + }, + "Lean.Meta.ReduceEval": { + "relative_path": "lib/lean/Lean/Meta/ReduceEval.olean", + "sha256": "50aaeb5ac37fb6154b0e2c1c5d3085f3cf61736ec3b316ab2bd9e7d4d7babc40" + }, + "Lean.Meta.SizeOf": { + "relative_path": "lib/lean/Lean/Meta/SizeOf.olean", + "sha256": "af408b51fc723ab8bd677b7e5a84d33b6639d1e481b7f058d3e5f16200c7a5c5" + }, + "Lean.Meta.Sorry": { + "relative_path": "lib/lean/Lean/Meta/Sorry.olean", + "sha256": "56b4c84f52c8c7925b6c1a850fb91ff7d7966e113ed79a39e140ae46f5fde7a9" + }, + "Lean.Meta.Structure": { + "relative_path": "lib/lean/Lean/Meta/Structure.olean", + "sha256": "e5f9fa309279c95a5cf27878c316b302eba85e26b4aa1d6e85f5b43d6453616a" + }, + "Lean.Meta.SynthInstance": { + "relative_path": "lib/lean/Lean/Meta/SynthInstance.olean", + "sha256": "dc0a3b8ea0ef34849ba5ca57477fd5ccb37d7ccad92151d8b231f17afb86c5dd" + }, + "Lean.Meta.Tactic": { + "relative_path": "lib/lean/Lean/Meta/Tactic.olean", + "sha256": "ad4914ed10cf80c2d4a2388d6fb8af91cc2d2991c9475e8cab2eb6ba7d57ea22" + }, + "Lean.Meta.Tactic.AC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AC.olean", + "sha256": "ee57ccf20ad198b447ea1b6e0f7ceb4a6b3ae399b5dc45ca144164e7f41148fc" + }, + "Lean.Meta.Tactic.AC.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AC/Main.olean", + "sha256": "2bdbf30c5961d39ed784e11ba8bbbee10f34d882c8e515bfedfaae65c2983174" + }, + "Lean.Meta.Tactic.Acyclic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Acyclic.olean", + "sha256": "1d138ed59a13cdb5360dee24852ee3dcef4d97a3da34e175c3d5ba1a5afbfe98" + }, + "Lean.Meta.Tactic.Apply": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Apply.olean", + "sha256": "c1283b20feace19b65fc7e23af16221b8d0a14ac59dd7c70d8d0a83222e94baa" + }, + "Lean.Meta.Tactic.Assert": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Assert.olean", + "sha256": "7673647ca3e547e0078675263dc676f122d87c602266d432c78229cb716be2fe" + }, + "Lean.Meta.Tactic.Assumption": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Assumption.olean", + "sha256": "bbe1c2ac91bb85c39556a28690834034b3faff15ffa79f396f5646154597185b" + }, + "Lean.Meta.Tactic.AuxLemma": { + "relative_path": "lib/lean/Lean/Meta/Tactic/AuxLemma.olean", + "sha256": "b621afecfc83539db089cf44ceee268d994ee0371559db2bafee8341ade61caa" + }, + "Lean.Meta.Tactic.Backtrack": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Backtrack.olean", + "sha256": "6ba89a26edd430b58166fa46607e7b7e7904172b1984de835b7eb9a584fec426" + }, + "Lean.Meta.Tactic.Cases": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Cases.olean", + "sha256": "f82be51283b6ca0a88b466e325061872da1ca78317d784222c2d4d5f095f25d9" + }, + "Lean.Meta.Tactic.Cleanup": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Cleanup.olean", + "sha256": "5daf92f058790a58da353d444701d231bc0d7ffac8ac7a641a396f71c09150d2" + }, + "Lean.Meta.Tactic.Clear": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Clear.olean", + "sha256": "829fa3bd204a603f0686f6060b474f98815ba786324b91fbf166c40783702c4b" + }, + "Lean.Meta.Tactic.Congr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Congr.olean", + "sha256": "2fe9a126baf313a410bca67c2ba600b5397776b3096845ca5bfd4c71f4065195" + }, + "Lean.Meta.Tactic.Constructor": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Constructor.olean", + "sha256": "867577fa39e8b883035764c3dc65017fdb335a365931aab74461676eb3d4ff43" + }, + "Lean.Meta.Tactic.Contradiction": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Contradiction.olean", + "sha256": "4f2fea4e956ca33f43b6958efcba64ec2f7da8199bf2e8305ea09dc0a9a387be" + }, + "Lean.Meta.Tactic.Delta": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Delta.olean", + "sha256": "b80e1e36a4f334d593cc5c2692020ccf113e0066cb9bccf59b88d706a1ed3303" + }, + "Lean.Meta.Tactic.ElimInfo": { + "relative_path": "lib/lean/Lean/Meta/Tactic/ElimInfo.olean", + "sha256": "59a71e16fbbfb5a22573b245e4d7068eee6d9b0d40b49602cdd03e0d4e9bdc5a" + }, + "Lean.Meta.Tactic.ExposeNames": { + "relative_path": "lib/lean/Lean/Meta/Tactic/ExposeNames.olean", + "sha256": "3b31fb2dba571938bce63170aadf82501c229ac457caad8427c58eef935ba444" + }, + "Lean.Meta.Tactic.Ext": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Ext.olean", + "sha256": "22bb0d168e310524c9788a3c415614b51ed048dbfd5a51652f46b0068c77b4a2" + }, + "Lean.Meta.Tactic.FVarSubst": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FVarSubst.olean", + "sha256": "8c21b3a5802e4d08978539b78c1dbb67508903b3f21978b38ef9cc57c270a27c" + }, + "Lean.Meta.Tactic.FunInd": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunInd.olean", + "sha256": "6296c74e67fb553b1bc764a5e07c2d5bbb6c4ebd3b323557c64d01267d1801ab" + }, + "Lean.Meta.Tactic.FunIndCollect": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunIndCollect.olean", + "sha256": "abb578a79335d722c9d69eef073a1ccb64c966b6b7dcdf501b9825181ea2165d" + }, + "Lean.Meta.Tactic.FunIndInfo": { + "relative_path": "lib/lean/Lean/Meta/Tactic/FunIndInfo.olean", + "sha256": "7fcea4ed90a733cf9b1d874e6c805f123f293da6379e4a658df2333f64cd5bc5" + }, + "Lean.Meta.Tactic.Generalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Generalize.olean", + "sha256": "c6b2a2530dbb3966ededa8eec4476801bc7c85e1a69c17519d2b47a6e3bb3047" + }, + "Lean.Meta.Tactic.Grind": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind.olean", + "sha256": "a4a04684e58d43aa05cb1c41eb3e18cf6af8da64c935a88fea4b41e394461a78" + }, + "Lean.Meta.Tactic.Grind.Arith": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith.olean", + "sha256": "3cb51d31133b73246d8131265dafb9cede95fc310dbe7bb4b5b7ece65b2598ad" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat.olean", + "sha256": "dd481e2963c500cd4c4f686f800ae5d5ab818b1055fcd1cb95bab98516dbf96e" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/DvdCnstr.olean", + "sha256": "78cc1a489ac6c1dd48dbeae02db742ed4a0867263e877192ab4b417807b73251" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/EqCnstr.olean", + "sha256": "bd0a7b837aeda3d44ba972c14219b3f8bf1fda4e68fa1b7b2a98b911007d6ae0" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Inv.olean", + "sha256": "1e84cc67e9674371b9e1ee937f052ebaf33f949ee98fed97ae3e5a0af14ad8bc" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/LeCnstr.olean", + "sha256": "bbaf4808f9bef4fd58cffdd9dbbebcaae4a275b740f912f4357bfcd71807dad1" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/MBTC.olean", + "sha256": "bb82e33912900ffca9cb8b05ba27175bc5be751f59921b09f13322dff9997fdb" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Model.olean", + "sha256": "868752823c6951c957840f933609d6fe1dc86026fd810479862fdc3c73b84399" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Nat.olean", + "sha256": "8092837e82e32858cfe423c1f20453c3c38a013c54abb05f872b1233cfbe8e5f" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Norm.olean", + "sha256": "370a4249179e8a0d228121d74a22194b50afc23395fcc3d8024621527d703ac1" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Proof.olean", + "sha256": "3c8f3c889d553bf6ef43ed0c444859e905cd162356ce04f85247b0456a4f7b4e" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Search": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Search.olean", + "sha256": "61aca638560fc03fc81066bda85ae7ed4cd041d810cd6ccfc22126d34acddbd5" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/SearchM.olean", + "sha256": "50bd8fa6211db0a214bd45a0f0e39b717459c16a30ecb25f9cb952d8375bccef" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Types.olean", + "sha256": "049f36bd49ee5222ca1f80966c97b13f53c4c7d9671d9cf496d582bf1c502671" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Util.olean", + "sha256": "d9541c657bbd8498736f341ac0e4389234e57be3d769b33a637f951da6e098f7" + }, + "Lean.Meta.Tactic.Grind.Arith.Cutsat.Var": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Cutsat/Var.olean", + "sha256": "2da35cd1a1295137544c382e41dbe533cd98dc6fc18c92de7a0c8986518f48ac" + }, + "Lean.Meta.Tactic.Grind.Arith.Internalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Internalize.olean", + "sha256": "1f8dbae8cba46c6011d127e73c6d23e1594b3c13079a8167c9ff0b5d55ceaeb9" + }, + "Lean.Meta.Tactic.Grind.Arith.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Inv.olean", + "sha256": "0750fb3fce8b1e8ec98480b4b6ab8360e5f205371b1d575f53357702ae2bb702" + }, + "Lean.Meta.Tactic.Grind.Arith.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Main.olean", + "sha256": "8eb37977bf901bab0ad9873bfbde7c593fbaf6ff8d0c1c6de61597ec91de58c0" + }, + "Lean.Meta.Tactic.Grind.Arith.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Model.olean", + "sha256": "52f869b8a4523f3f8327495940a786c4670cf48b997d432c20640384e7301003" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset.olean", + "sha256": "bd8b615afcb4c53f5e711d9ab7f88881785088cd9b9f81c6b80b64432a916166" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Main.olean", + "sha256": "817db989d2e71b096c86076070f270ce02efefcf2c4b0cc8eb35a85ffe592097" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Model": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Model.olean", + "sha256": "3ffe0874b9209d41c8a12f845f4a23c37ed67985952ec8cf4fba6607b0d49bb2" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Proof.olean", + "sha256": "13e17f706763e0e5001c386f41180d240fcc3cb3bb0e5b0704b1c6e89f8690dc" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Types.olean", + "sha256": "2af0eddf89eb682293b49189b0ecfdb86e7b2cb70ca6983d35edba6fc47b6825" + }, + "Lean.Meta.Tactic.Grind.Arith.Offset.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Offset/Util.olean", + "sha256": "cc0adfcd94231e97e1d8a5d9fd855b4ba06f77d4974d9f60bf8fcb1fad3429cb" + }, + "Lean.Meta.Tactic.Grind.Arith.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Types.olean", + "sha256": "6438183d9d97bcba306b3c98d0c4df35f16ae24156cbd92211a215ee8e0e9508" + }, + "Lean.Meta.Tactic.Grind.Arith.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Arith/Util.olean", + "sha256": "059afefed5207fd3bb58ff11aa196e5cb4fdd3d0c2f03f70ab3a302f3fb59612" + }, + "Lean.Meta.Tactic.Grind.Attr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Attr.olean", + "sha256": "e0809449692b76c1e0ae127a742c8c83858306fe2612eb59a238e5600e6437b0" + }, + "Lean.Meta.Tactic.Grind.Beta": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Beta.olean", + "sha256": "34027591ddea6317ba5bc6f29ec01c6a1cd2dc75c8b2af5b5d5e6fede7c2813f" + }, + "Lean.Meta.Tactic.Grind.Canon": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Canon.olean", + "sha256": "7e0dcfb39fd87bd7aa566da21f8cf3e0055adf5abdfab8c4dcd92ff022cffc99" + }, + "Lean.Meta.Tactic.Grind.Cases": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Cases.olean", + "sha256": "a79fdef9eaf0a5a89b2369d0374b43efa50ef7eb137bb143aea1b6968130fcd5" + }, + "Lean.Meta.Tactic.Grind.CasesMatch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/CasesMatch.olean", + "sha256": "cae5f088bd9191b15683eb230c385d3cf95b9cc36c5aa8fd237ef6abd6240e79" + }, + "Lean.Meta.Tactic.Grind.Combinators": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Combinators.olean", + "sha256": "573a8a2af44136b8fde8d93f561948f97b61ed2b0445b4af06a07e82901b004c" + }, + "Lean.Meta.Tactic.Grind.Core": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Core.olean", + "sha256": "603facdbeba83aeb053dc352948b86af9017b6a6e7b546a1a1516f03fea9c273" + }, + "Lean.Meta.Tactic.Grind.Ctor": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Ctor.olean", + "sha256": "2e49aeb70d54c80eecfae5c718a65d31917c4d875090b306049d463db43c230b" + }, + "Lean.Meta.Tactic.Grind.Diseq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Diseq.olean", + "sha256": "712b2965e98032727d42acecf75d2845c6d20828c9aa6f4cb7346b51100c6761" + }, + "Lean.Meta.Tactic.Grind.EMatch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatch.olean", + "sha256": "b3075bba2fa4af4839446ccc345b04063a1eeaf1f396aa027550e0d67eaf46d6" + }, + "Lean.Meta.Tactic.Grind.EMatchTheorem": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EMatchTheorem.olean", + "sha256": "7e393dd56ee80f27d92e457f4c2070d2fe2831142981438b7dff6b652ed6b12e" + }, + "Lean.Meta.Tactic.Grind.ENodeKey": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ENodeKey.olean", + "sha256": "ca0345179b9421b8efb30bed06820116843d9701e9c9f84e0824a0961b5251a5" + }, + "Lean.Meta.Tactic.Grind.EqResolution": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/EqResolution.olean", + "sha256": "ed9d38ede8c44a14131ac484fcaac127fd889468856ea78f158cb8f7c7c5f9e1" + }, + "Lean.Meta.Tactic.Grind.Ext": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Ext.olean", + "sha256": "a7c1cee7f1e76d45b3787d0a7c2036967fffd7c6d780dad968bc5e08e0c674c7" + }, + "Lean.Meta.Tactic.Grind.ForallProp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ForallProp.olean", + "sha256": "923892a0ed79c2156b6df9cc23f561b77dc2c935ccb9b1d95122bab0e20fef97" + }, + "Lean.Meta.Tactic.Grind.Injection": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Injection.olean", + "sha256": "7c448e2fc0d16e61b6ad822651c7b35b8213dd18fbd4927017595d9fcd96af63" + }, + "Lean.Meta.Tactic.Grind.Internalize": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Internalize.olean", + "sha256": "7cd74b074c2e9deae6791b7045b6dec8f9056d41b96c9072020b051d67402323" + }, + "Lean.Meta.Tactic.Grind.Intro": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Intro.olean", + "sha256": "45d35493ac631af84097a78ea4b02bc5cc814c0ac8b598b36049279ac7ed87f3" + }, + "Lean.Meta.Tactic.Grind.Inv": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Inv.olean", + "sha256": "5111a484cd46c8d2263629540e4128cef9f30b74ccf62a6eded8ac56d8481fa3" + }, + "Lean.Meta.Tactic.Grind.MBTC": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MBTC.olean", + "sha256": "596858a07ca041824937bfd08b38cdef09d32b08749962546f2b8abdb7e24192" + }, + "Lean.Meta.Tactic.Grind.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Main.olean", + "sha256": "e1e5ab7d0c967a50c2a38a5490a1a8c537e843da2c3f5a56e7cda971208bfd93" + }, + "Lean.Meta.Tactic.Grind.MarkNestedProofs": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MarkNestedProofs.olean", + "sha256": "3ab8dc54fab42c6683c63aae87ad0e606b3832d1f2391087ec7e698d5fa2fbcb" + }, + "Lean.Meta.Tactic.Grind.MatchCond": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchCond.olean", + "sha256": "ab35239747c6ca8c3833e709aaa2aa723d0525620ac2634241f72963ac9bed82" + }, + "Lean.Meta.Tactic.Grind.MatchDiscrOnly": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/MatchDiscrOnly.olean", + "sha256": "0de0cdfbedfabfa048e98e885f3f1eea39e583aec8bcc2a50a5698f7a0df7884" + }, + "Lean.Meta.Tactic.Grind.PP": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/PP.olean", + "sha256": "23d560a5339928172099a9062d083f940a0a16e6c0b784dfe2a9f356e8682bb7" + }, + "Lean.Meta.Tactic.Grind.Parser": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Parser.olean", + "sha256": "052643551a1eb5fbfe4afdca2eb7ae6260628ef93f4813744cbda5a138eb751a" + }, + "Lean.Meta.Tactic.Grind.Proj": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Proj.olean", + "sha256": "1383ad6bc4a47cea522c9b9f542049aad4b818f4bf208ed98d1f56088d322a9a" + }, + "Lean.Meta.Tactic.Grind.Proof": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Proof.olean", + "sha256": "7e5f3d9016d71c938eb5bf7c6188d50dfe2b148189748b018e13d1d1f26758c0" + }, + "Lean.Meta.Tactic.Grind.Propagate": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Propagate.olean", + "sha256": "ba25b0259e25398cb28d7a6343b76a9ffae30a0e7759f2bbba03cf439d27ee49" + }, + "Lean.Meta.Tactic.Grind.PropagatorAttr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/PropagatorAttr.olean", + "sha256": "c21c3865df64f8a2bdab20ab5a5658badebe0b370640e63e7ce8ae0620bc98b3" + }, + "Lean.Meta.Tactic.Grind.ProveEq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/ProveEq.olean", + "sha256": "6fd15eeee6dce37a980a5036eb99716960dbbc6650d14b71cbd63a0f854578e7" + }, + "Lean.Meta.Tactic.Grind.RevertAll": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/RevertAll.olean", + "sha256": "63335a05f51b1b99b3bc891e774ed07ae7ccf470b36701c9a47472a2023b72dc" + }, + "Lean.Meta.Tactic.Grind.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Simp.olean", + "sha256": "eb9a419af181bdcc13018b73f8b5ef9b0cce6b3d8e69bb777a9464d54d7489d0" + }, + "Lean.Meta.Tactic.Grind.SimpUtil": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/SimpUtil.olean", + "sha256": "082ec13ed64da168e10a1d19d1f2080f417e069936488d9628652d2e83bf96ab" + }, + "Lean.Meta.Tactic.Grind.Solve": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Solve.olean", + "sha256": "838552f0e3f9901c03de3ee16533956fcc7677abcd393eaa85fc7e14c67c0c07" + }, + "Lean.Meta.Tactic.Grind.Split": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Split.olean", + "sha256": "9be21a776a8dbb641a0af947eebf4525341bfa829b3ae7e7ed5eb20855727d37" + }, + "Lean.Meta.Tactic.Grind.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Types.olean", + "sha256": "50bd2bb81627e5f915ee54c8730bb4d5403de12cca8a05a41f2f280b693772f9" + }, + "Lean.Meta.Tactic.Grind.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Grind/Util.olean", + "sha256": "02603b8094844f61ba32b6173beb06896e101dac5d581ca4ef9e82b17f4ba473" + }, + "Lean.Meta.Tactic.IndependentOf": { + "relative_path": "lib/lean/Lean/Meta/Tactic/IndependentOf.olean", + "sha256": "d6abc51e9488051912586a96926f55ddb9f0368c8891d5f89ff2d684122148fe" + }, + "Lean.Meta.Tactic.Induction": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Induction.olean", + "sha256": "a8fdc96571cc600fd47e2e68d84c51fe8afc537c08ab63d1e69ba5b4f518f4fa" + }, + "Lean.Meta.Tactic.Injection": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Injection.olean", + "sha256": "6d25fe6e9d8e4af470d9cd1074402577fd08575b0306faf9c78411c8a5e7578a" + }, + "Lean.Meta.Tactic.Intro": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Intro.olean", + "sha256": "a781ab0eafda9549477f2e90e0dc6ea708bbbda6d12f7390eaba879ecf6146a7" + }, + "Lean.Meta.Tactic.LibrarySearch": { + "relative_path": "lib/lean/Lean/Meta/Tactic/LibrarySearch.olean", + "sha256": "c943f49809c5e0037e4239b05e441c2331cb48b24ca17f9146e5197458ed3ad6" + }, + "Lean.Meta.Tactic.NormCast": { + "relative_path": "lib/lean/Lean/Meta/Tactic/NormCast.olean", + "sha256": "8758122a8aa03b65194824837c9501ff7a57f6e56c3645ce16cd39935122465b" + }, + "Lean.Meta.Tactic.Refl": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Refl.olean", + "sha256": "39762b479efc2290610ab53ea0f9a7a67643f6684cb0fa5cdc1ff52cd5589d8a" + }, + "Lean.Meta.Tactic.Rename": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rename.olean", + "sha256": "633edd2088d9aab13bbb93c7da98451571c025dd4fa28c7adb7a1f14dede0a82" + }, + "Lean.Meta.Tactic.Repeat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Repeat.olean", + "sha256": "54854192d18a935b34a838ec68e7b5c86f7efc2831bbfe623057415260b84553" + }, + "Lean.Meta.Tactic.Replace": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Replace.olean", + "sha256": "a542783069ace49d9d9e92aa9f3cb725c98f94d5cdd4977a1154569dad20f1b5" + }, + "Lean.Meta.Tactic.Revert": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Revert.olean", + "sha256": "f6454fe8a940ada423be12c9a36033ecfbba13b71d0ed59fad2e9d522d46df10" + }, + "Lean.Meta.Tactic.Rewrite": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rewrite.olean", + "sha256": "3d61c66d1f775792f0c463b3ef6666a399fff92c2f7f1b29c605c99e02941897" + }, + "Lean.Meta.Tactic.Rewrites": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rewrites.olean", + "sha256": "5a2278edd2383bca036422ea43a484ccae7a0bb2bc7e7e15f0326a32e2330786" + }, + "Lean.Meta.Tactic.Rfl": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Rfl.olean", + "sha256": "d2e5e722c4f2e3c9f291c02c05a671917d71aef645e34c0c01dbfd8a4ef23898" + }, + "Lean.Meta.Tactic.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp.olean", + "sha256": "a744b6973cd9b833699a6c19c0fa40e4dbfb6041fb08a6ca4de0823d3d56fae0" + }, + "Lean.Meta.Tactic.Simp.Arith": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith.olean", + "sha256": "b8b2030520be215f2121c9fab8608f7fd58ea80e48ffa5598fce3d1f948950c1" + }, + "Lean.Meta.Tactic.Simp.Arith.Int": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int.olean", + "sha256": "4f1c85c9e598fc31a7e1fc7e6f8d06d1c1eaa5146c624842e8ec87b58e5d9994" + }, + "Lean.Meta.Tactic.Simp.Arith.Int.Basic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Basic.olean", + "sha256": "d03e49ecd4dfdec58f2ac9f261d983bea4023df4c78f7514bb7f6c40cdbb8bbf" + }, + "Lean.Meta.Tactic.Simp.Arith.Int.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Int/Simp.olean", + "sha256": "2766ba66e280f3beb4bae57de6de59a2f92647472cbe608bec350dbabdaaba11" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat.olean", + "sha256": "a035ca9e9317ad56e2e70046e0864586827218ad7e25cb7366fe532e010b1007" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat.Basic": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Basic.olean", + "sha256": "f80614c7ae4ff336b04162d11f2574e0848f38f72882fe919d759eaa09590f72" + }, + "Lean.Meta.Tactic.Simp.Arith.Nat.Simp": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Nat/Simp.olean", + "sha256": "d77e898ebdaa21da0b6f6fa24eb4804a8b45ecf4ed7834aa26bfe8493b51148a" + }, + "Lean.Meta.Tactic.Simp.Arith.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Arith/Util.olean", + "sha256": "e43e2fa36cc77656ee34ca02b79897664215ce95e653cada87db0781111193ff" + }, + "Lean.Meta.Tactic.Simp.Attr": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Attr.olean", + "sha256": "59dacc00728793da658e06c75bf20eb166ca57c100434714c7a7b7349149e99b" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs.olean", + "sha256": "9e91488ad971f433fc8c18b870ddae5174f4fd8a80f9aee7e195223acf0813e7" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Array.olean", + "sha256": "aba24528cdf8549fefad4371d2ed8279dcc5bd4566d9ca59ccc721f760d51c56" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/BitVec.olean", + "sha256": "18ba1c46202bae2dd5205e93db1df217fc9d213fbdc687452d9d76421437ef66" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Char.olean", + "sha256": "70bb04834a476008fe448165e8662a0437c82012e348ec19b6039773051fc91d" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Core.olean", + "sha256": "5b8217fa58f2deae0b8a99202da2367fedbf91cda77486d0ea9201b05a0720ae" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Fin.olean", + "sha256": "fe618da592aafcfc1b597b118c88b962b603f55096926e7c77cd5f237a393c0e" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Int.olean", + "sha256": "9535c409ebeb0c3064e5b98fa9f953fbb93e15db3f2116dc46138ac0ff700c0a" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.List": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/List.olean", + "sha256": "93a9382bd2f855ac48c61e6886f02b85f81593552747a1dae72b3b10afc71a70" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Nat.olean", + "sha256": "6b8d3d8807c31912616ae4818014da1e44cbfa398eeae525170b864185b3f324" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/SInt.olean", + "sha256": "a14d545e6a296624fbfc25dc02e8a49e0be6e3285f47960af9dbb766e872a024" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.String": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/String.olean", + "sha256": "bae98881832f2482d6e98c1b9eb11cc28e984ee2b7ac2d3e3d92ceade31bb7c6" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/UInt.olean", + "sha256": "9afaab454e44fd3c1a60907f38ee31b9057682bb6b66503e3136b23a0e51a0eb" + }, + "Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/BuiltinSimprocs/Util.olean", + "sha256": "97194969f1662051ced0134ccd1cbc4051c02ed0afd46ecff6daafb413645652" + }, + "Lean.Meta.Tactic.Simp.Diagnostics": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Diagnostics.olean", + "sha256": "8fb74efbbe0d898b4bee2b53a996bb925cd3dfdd4bf3098086d07fdad9c093f6" + }, + "Lean.Meta.Tactic.Simp.Main": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Main.olean", + "sha256": "90f3c5c41d8d10a7b82110a9d188db8661f730c8430102696a6050a9e819944d" + }, + "Lean.Meta.Tactic.Simp.RegisterCommand": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/RegisterCommand.olean", + "sha256": "5e296fcd42394e5fa5a137358753eb347872076a0e8dc3ef5e31b483ac58af39" + }, + "Lean.Meta.Tactic.Simp.Rewrite": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Rewrite.olean", + "sha256": "e6377cde2f937751efc04e43b032505bfed7ec5c1f13678c3cb456268e90d2c2" + }, + "Lean.Meta.Tactic.Simp.SimpAll": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpAll.olean", + "sha256": "f2aedf17c8196a3fcc3ba0a79d2dee82b6599e2623e0e5336940943fe294316d" + }, + "Lean.Meta.Tactic.Simp.SimpCongrTheorems": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpCongrTheorems.olean", + "sha256": "2a29138060df8d5e09ad070b170d167fc490713073b36b38371e676c83578119" + }, + "Lean.Meta.Tactic.Simp.SimpTheorems": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/SimpTheorems.olean", + "sha256": "b6f48b1bf34a7832d9a809b108a3aa8606c13afd2376b6c2c79f7045425e0e7d" + }, + "Lean.Meta.Tactic.Simp.Simproc": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Simproc.olean", + "sha256": "913ac372ccd4b4445b346d16d2ba702bf74d8ea65e62401b7b502b016bc82750" + }, + "Lean.Meta.Tactic.Simp.Types": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Simp/Types.olean", + "sha256": "382bf34c3320d34ce0ba097804f91ee702480fb358709d1a376399ab20ae2767" + }, + "Lean.Meta.Tactic.SolveByElim": { + "relative_path": "lib/lean/Lean/Meta/Tactic/SolveByElim.olean", + "sha256": "65859e5f73882352b2e665afdd9ae7f9dbd122ef99cdaa6422fc4e37c030d459" + }, + "Lean.Meta.Tactic.Split": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Split.olean", + "sha256": "0e8d4c9c735a78acc8977e81bc84bd39d2390093d889445f006ba6d5f6ad5b3d" + }, + "Lean.Meta.Tactic.SplitIf": { + "relative_path": "lib/lean/Lean/Meta/Tactic/SplitIf.olean", + "sha256": "a39ffae4f96a41e30a2c3a88468103c3c716942214fc8805357490e903b2ef67" + }, + "Lean.Meta.Tactic.Subst": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Subst.olean", + "sha256": "44938a993d4998ad3140ba161843cf52fc0f01d8eb04dc105433e74f57e13dba" + }, + "Lean.Meta.Tactic.Symm": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Symm.olean", + "sha256": "9e576fa9ccc14f72a6d4b75f9ccb133f5463c531031fc0abcd81f9ce1e002b6b" + }, + "Lean.Meta.Tactic.Try": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Try.olean", + "sha256": "e2c566144935639f447b2493030d97204d22cfb866bd8c767ec0fba491cb56c2" + }, + "Lean.Meta.Tactic.Try.Collect": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Try/Collect.olean", + "sha256": "eb58abadce47d13437cc648de8c9c4d34965bde2b5b8c0fb5be46aa7c2f709bb" + }, + "Lean.Meta.Tactic.TryThis": { + "relative_path": "lib/lean/Lean/Meta/Tactic/TryThis.olean", + "sha256": "b0a43bfa4c21d9d9c9181de4783e7f7637862e6799dc17a94ffd41b6b8320535" + }, + "Lean.Meta.Tactic.Unfold": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Unfold.olean", + "sha256": "c512bf7a8ddc53bc480ed017efccdce73fa6a65ff3bc8026fcdb45108910a8f1" + }, + "Lean.Meta.Tactic.UnifyEq": { + "relative_path": "lib/lean/Lean/Meta/Tactic/UnifyEq.olean", + "sha256": "17895f0232b1c9b37739a6678bc125d5481c4711fd70dcc2e0d7533d2ae7d88a" + }, + "Lean.Meta.Tactic.Util": { + "relative_path": "lib/lean/Lean/Meta/Tactic/Util.olean", + "sha256": "26f024806a3c5a844167cad452c161e17dd535f37c2f70f76fa8d0e98ac7d898" + }, + "Lean.Meta.Transform": { + "relative_path": "lib/lean/Lean/Meta/Transform.olean", + "sha256": "0fad85dd417e805f932c54eada13d21053a7457b9154026cf16b38e3458fc759" + }, + "Lean.Meta.TransparencyMode": { + "relative_path": "lib/lean/Lean/Meta/TransparencyMode.olean", + "sha256": "8f195daac0641aeeb14c47bb8989f99929ddb79329d5b64dd4349bc21ad52fdc" + }, + "Lean.Meta.UnificationHint": { + "relative_path": "lib/lean/Lean/Meta/UnificationHint.olean", + "sha256": "f6400a3713e4a9a72e4f2ef064ebe692706c0f21f186dce75250fe6eb4138a85" + }, + "Lean.Meta.WHNF": { + "relative_path": "lib/lean/Lean/Meta/WHNF.olean", + "sha256": "13939b1cdb2a81230a5445e9836dadeead92b5810b293c5da265451f02dd516f" + }, + "Lean.MetavarContext": { + "relative_path": "lib/lean/Lean/MetavarContext.olean", + "sha256": "616fb991aae42c8780c3566eadfe5e7cbabbf4779da1cf138014130772a668e1" + }, + "Lean.Modifiers": { + "relative_path": "lib/lean/Lean/Modifiers.olean", + "sha256": "34a8b59c7358c3a176430743f45ff649c47511e16e8b38bc763e3d63d82d11ae" + }, + "Lean.MonadEnv": { + "relative_path": "lib/lean/Lean/MonadEnv.olean", + "sha256": "086512b6ccf3afb524b665d93bfa512c8d2f699dd55ee4d59acab9376c379659" + }, + "Lean.Namespace": { + "relative_path": "lib/lean/Lean/Namespace.olean", + "sha256": "a4eb3519381836c10a0afd99e58a248135c277cd2a9489cc77636877914df692" + }, + "Lean.Parser": { + "relative_path": "lib/lean/Lean/Parser.olean", + "sha256": "28d395e6f52a72577be7747cfd60a84d5fef0edbff614963675e7103f43ce066" + }, + "Lean.Parser.Attr": { + "relative_path": "lib/lean/Lean/Parser/Attr.olean", + "sha256": "d37af508df519b54e878fdf29c6ff2006c4ab3d66c189302f2e28d50fb53d01e" + }, + "Lean.Parser.Basic": { + "relative_path": "lib/lean/Lean/Parser/Basic.olean", + "sha256": "948a51872ed931dcd069d6717532f02760ec64f1acfd6862fc5d222cc6aedeb0" + }, + "Lean.Parser.Command": { + "relative_path": "lib/lean/Lean/Parser/Command.olean", + "sha256": "a095b104d809b21d76722139623c677f932cbe8f33f79077c0f7469facaa4d21" + }, + "Lean.Parser.Do": { + "relative_path": "lib/lean/Lean/Parser/Do.olean", + "sha256": "0d97f39e5ec556f827c8399724fc2c7ad26b9b7a3aa8583158c1b335d2962edc" + }, + "Lean.Parser.Extension": { + "relative_path": "lib/lean/Lean/Parser/Extension.olean", + "sha256": "3d5387205b22b17b0449553339d1449481eb01d1f90424c1920521dfbbd6a51d" + }, + "Lean.Parser.Extra": { + "relative_path": "lib/lean/Lean/Parser/Extra.olean", + "sha256": "26993ef7f1b0dc107e5a54f5346becb1ed7df9e287a9716ba9a90dc25cb5597a" + }, + "Lean.Parser.Level": { + "relative_path": "lib/lean/Lean/Parser/Level.olean", + "sha256": "028076fe879c3d1f470248400637a3b2a404bd2807c6b1c42bd9f19b37a87385" + }, + "Lean.Parser.Module": { + "relative_path": "lib/lean/Lean/Parser/Module.olean", + "sha256": "1cd96b90357d48c1313be94c170a60e06deab7c2230a7684a5d3ad39a41a1453" + }, + "Lean.Parser.StrInterpolation": { + "relative_path": "lib/lean/Lean/Parser/StrInterpolation.olean", + "sha256": "1f275289f803e6362acbbdbb64dcbd1f4b63a25d01b96104d8bad7419712270a" + }, + "Lean.Parser.Syntax": { + "relative_path": "lib/lean/Lean/Parser/Syntax.olean", + "sha256": "b7d13deae25970c03965ab71ee15b6079948b4031f5c7877b19253d75b32a9a8" + }, + "Lean.Parser.Tactic": { + "relative_path": "lib/lean/Lean/Parser/Tactic.olean", + "sha256": "1d5f60bbb0520f7381c7942188f25406b178ed74e64c6995b8136e9d410617c9" + }, + "Lean.Parser.Tactic.Doc": { + "relative_path": "lib/lean/Lean/Parser/Tactic/Doc.olean", + "sha256": "de5fa176afd2efb06130e19b1fad85a782e8f6c70abd81e07410c06bdaaf435c" + }, + "Lean.Parser.Term": { + "relative_path": "lib/lean/Lean/Parser/Term.olean", + "sha256": "c27cd04030908ee1296d32a8230508cf878e37d3d9b55dc54a33dfd8f7bbcbaf" + }, + "Lean.Parser.Term.Doc": { + "relative_path": "lib/lean/Lean/Parser/Term/Doc.olean", + "sha256": "48344268b22b852d1c35ae1a717dcd804b7e02cb6619538b521a0f9f7c5b75ec" + }, + "Lean.Parser.Types": { + "relative_path": "lib/lean/Lean/Parser/Types.olean", + "sha256": "ebb9269d0c74ef1b84ed10af9a0fcfebd8c5f06af78ea8b7de52fab501ec3801" + }, + "Lean.ParserCompiler": { + "relative_path": "lib/lean/Lean/ParserCompiler.olean", + "sha256": "dfcf227a5095244c4f18259255e84b7d7486916a13d15cc7d494bf8327e7ea01" + }, + "Lean.ParserCompiler.Attribute": { + "relative_path": "lib/lean/Lean/ParserCompiler/Attribute.olean", + "sha256": "0635f545bec6dc4635f71024582d1e77d8ea6ace85b71d596c241b8c5cbb7ae0" + }, + "Lean.PremiseSelection": { + "relative_path": "lib/lean/Lean/PremiseSelection.olean", + "sha256": "84ad62edb54be2f55ea548421e59915503f678f5a689528429cbd6b3a47f52c3" + }, + "Lean.PrettyPrinter": { + "relative_path": "lib/lean/Lean/PrettyPrinter.olean", + "sha256": "f3c54ec68adb7b306e7de49fe6e1cc53c591053f6d772c125120e35cc0e42762" + }, + "Lean.PrettyPrinter.Basic": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Basic.olean", + "sha256": "5c155123ea1a5935403072f161006d3609e769fa5971cc83b99217c93d269a70" + }, + "Lean.PrettyPrinter.Delaborator": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator.olean", + "sha256": "2832e05f38fb87dd795cde9f6529793009807c6599a36ca0655f04eceb2c216c" + }, + "Lean.PrettyPrinter.Delaborator.Attributes": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Attributes.olean", + "sha256": "f98afcbf332723561b6d466a6c129844cdaff8b8f55e79f43a0040d1a0eb6a5c" + }, + "Lean.PrettyPrinter.Delaborator.Basic": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Basic.olean", + "sha256": "e402ce6c7c87da5752f1ec58b3032275db4ee722342a55bc118ac16ccb31b129" + }, + "Lean.PrettyPrinter.Delaborator.Builtins": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Builtins.olean", + "sha256": "02e8e2ec8a01f0eeba7212f5f3731bad7811680c44c03045391acd6222e8246a" + }, + "Lean.PrettyPrinter.Delaborator.FieldNotation": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/FieldNotation.olean", + "sha256": "0fd7dac9c26de870462ff5c02bfa167ddba6d4b6f5616e9cd0849bf410997dc1" + }, + "Lean.PrettyPrinter.Delaborator.Options": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/Options.olean", + "sha256": "83038fe17fe8486d5c2d49c942c60f40a56a857ea203991d52b0877f4c96ebdd" + }, + "Lean.PrettyPrinter.Delaborator.SubExpr": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/SubExpr.olean", + "sha256": "0d284ad4e40cc16bff17d232de10dee13bfa15b68eeda439218984488a864cef" + }, + "Lean.PrettyPrinter.Delaborator.TopDownAnalyze": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Delaborator/TopDownAnalyze.olean", + "sha256": "ae6466c25b02f08e0b5fdfa1d2905b521de447c99ed580026aeaf3fcbac14d54" + }, + "Lean.PrettyPrinter.Formatter": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Formatter.olean", + "sha256": "348c5cf96f47b9c3b5d672b87913ac267d4c9f6ab5cc6e1e46757b9a4898470f" + }, + "Lean.PrettyPrinter.Parenthesizer": { + "relative_path": "lib/lean/Lean/PrettyPrinter/Parenthesizer.olean", + "sha256": "d11ccf31a884b96dd8e7ce4a3d0be88ee37572282cc77235996eb06283ff9e1e" + }, + "Lean.PrivateName": { + "relative_path": "lib/lean/Lean/PrivateName.olean", + "sha256": "01331d62033f1a153ccfce0e26b19eec216989653b9170e09690f3f30017cd9e" + }, + "Lean.ProjFns": { + "relative_path": "lib/lean/Lean/ProjFns.olean", + "sha256": "b4e573e1214a33dfb17c70b252e55c42d56cbaa3ee3a02b620fc3cb238587772" + }, + "Lean.ReducibilityAttrs": { + "relative_path": "lib/lean/Lean/ReducibilityAttrs.olean", + "sha256": "4474586ad1da6481575424de924659c612a3e8c6b715ddf34fc26039d2e51e29" + }, + "Lean.Replay": { + "relative_path": "lib/lean/Lean/Replay.olean", + "sha256": "b99332f1e48cab089d45ecc5b6fadb71f95adb915b95ac7d5f513b8866b65d4e" + }, + "Lean.ReservedNameAction": { + "relative_path": "lib/lean/Lean/ReservedNameAction.olean", + "sha256": "c4c0b3460d35f4083a2459f232a0ff881e69092173963b6a671550a8640b3b41" + }, + "Lean.ResolveName": { + "relative_path": "lib/lean/Lean/ResolveName.olean", + "sha256": "1c5302ed5d1925a703364dbb22a84eb835a738d1073a1f576eafb4551b2f6863" + }, + "Lean.Runtime": { + "relative_path": "lib/lean/Lean/Runtime.olean", + "sha256": "f2c44c67f19cf22efd8c35ebb08d645de14a15341ce43055392e503f90c96ebf" + }, + "Lean.ScopedEnvExtension": { + "relative_path": "lib/lean/Lean/ScopedEnvExtension.olean", + "sha256": "a81bf05e51a27486ca11bb4b7f627a71278be383d69c04380886f8be0d7fd0fe" + }, + "Lean.Server": { + "relative_path": "lib/lean/Lean/Server.olean", + "sha256": "bbd9570762b5728fbeba1cd4fb6e1e63d0dc1e2f2b117cafd9e7fcae9bad7637" + }, + "Lean.Server.AsyncList": { + "relative_path": "lib/lean/Lean/Server/AsyncList.olean", + "sha256": "d9ecedd556a8565e22c4c4ef375e498bcf46cff541631685e3c6bb59da13ec06" + }, + "Lean.Server.CodeActions": { + "relative_path": "lib/lean/Lean/Server/CodeActions.olean", + "sha256": "1ffd438b12bf14992169052902dc91ff981fbffbd5b9d9dc3cd351afadf2d924" + }, + "Lean.Server.CodeActions.Attr": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Attr.olean", + "sha256": "21177a969ea2086c19c19a7d71a2d66acd666bfbd49c77dff89a2193ab911100" + }, + "Lean.Server.CodeActions.Basic": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Basic.olean", + "sha256": "3092af6beab4d2ccbcdc4d3c493887fbc61d2fd8c6507359d8dc81515af83350" + }, + "Lean.Server.CodeActions.Provider": { + "relative_path": "lib/lean/Lean/Server/CodeActions/Provider.olean", + "sha256": "aca19e7414b6c15aa725debc884e06aa48515bc10f78bdac847e92a0d3355945" + }, + "Lean.Server.Completion": { + "relative_path": "lib/lean/Lean/Server/Completion.olean", + "sha256": "2d2b0e130132eee10776deb68540afbf5c588598b4f858be9850099e64e8039e" + }, + "Lean.Server.Completion.CompletionCollectors": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionCollectors.olean", + "sha256": "ca660a9b742f1e2f6adf50cc33847122c9bc017880a643d63a56053091cb9f8d" + }, + "Lean.Server.Completion.CompletionInfoSelection": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionInfoSelection.olean", + "sha256": "229a4e0e5238f4af4a9165f077e381a739b385a957ec1fe5590d0329711a221d" + }, + "Lean.Server.Completion.CompletionItemData": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionItemData.olean", + "sha256": "aa592a1060191b06553a282b4e2c23583260bbd32f193fdd82a2a0e3881b2ea5" + }, + "Lean.Server.Completion.CompletionResolution": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionResolution.olean", + "sha256": "1f1e99acc389c5ef5818bcc8c7c5e2a2ed0058e0be93661a2b2aaf6c4ccf3220" + }, + "Lean.Server.Completion.CompletionUtils": { + "relative_path": "lib/lean/Lean/Server/Completion/CompletionUtils.olean", + "sha256": "1b68673e815b0792013d12790d4bcf8768326df0b7ff0244cf27d3b1fb4603d7" + }, + "Lean.Server.Completion.EligibleHeaderDecls": { + "relative_path": "lib/lean/Lean/Server/Completion/EligibleHeaderDecls.olean", + "sha256": "f71255170c2f18efa266279cda6ec56942e0975689ccd22ec7eaaff127d8433b" + }, + "Lean.Server.Completion.ImportCompletion": { + "relative_path": "lib/lean/Lean/Server/Completion/ImportCompletion.olean", + "sha256": "aed78476c5e3c1d841563b30a1076e4d8392383fc0ba65273f50f96057bb3a5e" + }, + "Lean.Server.Completion.SyntheticCompletion": { + "relative_path": "lib/lean/Lean/Server/Completion/SyntheticCompletion.olean", + "sha256": "6d1733deb5c375a5d09f69a8719d6f0cd91659aac517071e22d50d8c1072d2ca" + }, + "Lean.Server.FileSource": { + "relative_path": "lib/lean/Lean/Server/FileSource.olean", + "sha256": "e28757c52a99267f3c788a9e83b0d30a1461d4113065f45444269fdf7b18f9ae" + }, + "Lean.Server.FileWorker": { + "relative_path": "lib/lean/Lean/Server/FileWorker.olean", + "sha256": "f6529233eb4cc58fd4ce7426ece4285e7b294fcd924f80e60759a609ce75ab4c" + }, + "Lean.Server.FileWorker.ExampleHover": { + "relative_path": "lib/lean/Lean/Server/FileWorker/ExampleHover.olean", + "sha256": "159199fc8757162b59d3e4882a5adde20b9d30f1e1c2e9d73f2d431d8225f8b2" + }, + "Lean.Server.FileWorker.InlayHints": { + "relative_path": "lib/lean/Lean/Server/FileWorker/InlayHints.olean", + "sha256": "a6a0a9f601e15e5f0a4f1a4c58cccfa47a090ddcea06b087cf4d35f83bc8acb8" + }, + "Lean.Server.FileWorker.RequestHandling": { + "relative_path": "lib/lean/Lean/Server/FileWorker/RequestHandling.olean", + "sha256": "bb4929eaa8e2895d7dede2dfcee916694296993384310e57cb44c2f207c769cb" + }, + "Lean.Server.FileWorker.SemanticHighlighting": { + "relative_path": "lib/lean/Lean/Server/FileWorker/SemanticHighlighting.olean", + "sha256": "18293c05d11ec7a4479e7139013a5da2244e92d2a15f6fe0683f5aa25910839c" + }, + "Lean.Server.FileWorker.SetupFile": { + "relative_path": "lib/lean/Lean/Server/FileWorker/SetupFile.olean", + "sha256": "6aadbc90fb133de6196241264b5e9199eb20873ac28c97fd525020b9d1ff8117" + }, + "Lean.Server.FileWorker.Utils": { + "relative_path": "lib/lean/Lean/Server/FileWorker/Utils.olean", + "sha256": "fb1141d854ddd8285b816247a29f6c73f55bdbb57598d5b23b5689b2dd5bc6b4" + }, + "Lean.Server.FileWorker.WidgetRequests": { + "relative_path": "lib/lean/Lean/Server/FileWorker/WidgetRequests.olean", + "sha256": "b6a3538e82fcf0053a603dd6b89dae5ac056f25833d5af7671d9f5730eccc0be" + }, + "Lean.Server.GoTo": { + "relative_path": "lib/lean/Lean/Server/GoTo.olean", + "sha256": "18aa8fbcc0ca8c945db6e6aa3eed8ed4ca27a7c9e08ba86af3f8be0828608cf4" + }, + "Lean.Server.InfoUtils": { + "relative_path": "lib/lean/Lean/Server/InfoUtils.olean", + "sha256": "77b7e95c6f553154b841639d2aa3bb24346e89434327ddcb557b5982e4de69de" + }, + "Lean.Server.References": { + "relative_path": "lib/lean/Lean/Server/References.olean", + "sha256": "de438915fcb962e19d09bfd1905df6632459853730bf416cbe9c1bcae4fe515f" + }, + "Lean.Server.RequestCancellation": { + "relative_path": "lib/lean/Lean/Server/RequestCancellation.olean", + "sha256": "cd8942ec9337da649a58c9f8ea7f01ecce2383c59e080f22116f48f386be3ee0" + }, + "Lean.Server.Requests": { + "relative_path": "lib/lean/Lean/Server/Requests.olean", + "sha256": "0ae37f883b90fbbbb165411871f2f1bf1cc6f166efca062dd8869f14c845c828" + }, + "Lean.Server.Rpc": { + "relative_path": "lib/lean/Lean/Server/Rpc.olean", + "sha256": "640216f0a569300668056ade5912685e2a0543328feba76d00a752859c3b692d" + }, + "Lean.Server.Rpc.Basic": { + "relative_path": "lib/lean/Lean/Server/Rpc/Basic.olean", + "sha256": "09a13a5b0eb1c751cf1689334e7d858d4db582a65bd458efd638a20153839f73" + }, + "Lean.Server.Rpc.Deriving": { + "relative_path": "lib/lean/Lean/Server/Rpc/Deriving.olean", + "sha256": "398279634e15fa8d0aa9394bc63d5ec59a867598db64d76e4772549ba8d29aec" + }, + "Lean.Server.Rpc.RequestHandling": { + "relative_path": "lib/lean/Lean/Server/Rpc/RequestHandling.olean", + "sha256": "0af5a93b3960757ec7bc913b866e9c8bb12a0d3d966d5701f526174d53342c8e" + }, + "Lean.Server.ServerTask": { + "relative_path": "lib/lean/Lean/Server/ServerTask.olean", + "sha256": "5b6e96d39b1fb04527dfe5efb97b1118c1947d723f31cac6c97f8815ad8624a5" + }, + "Lean.Server.Snapshots": { + "relative_path": "lib/lean/Lean/Server/Snapshots.olean", + "sha256": "0fc97604d59c24d8ee81fd5a63dc5ae1abbdc7f9d88e4cdb15eaaee0d0da0991" + }, + "Lean.Server.Test": { + "relative_path": "lib/lean/Lean/Server/Test.olean", + "sha256": "2afbefa351dbf1bcf23b5bfaad40f909905680ad39e528f867b4c463d3db58b1" + }, + "Lean.Server.Test.Cancel": { + "relative_path": "lib/lean/Lean/Server/Test/Cancel.olean", + "sha256": "f33dbeb8bdf19c481feee5ee16bae1d773e043a294995bd4a11f94f604b8771b" + }, + "Lean.Server.Test.Runner": { + "relative_path": "lib/lean/Lean/Server/Test/Runner.olean", + "sha256": "1c8d1946a902c7331616a9a9f7be3d8db6dd5bbe233698c23150fa37043b147d" + }, + "Lean.Server.Utils": { + "relative_path": "lib/lean/Lean/Server/Utils.olean", + "sha256": "c2a03554a131bed630c8b57d965b78c635062a6ac5d29086d801b76e9c3c1e5e" + }, + "Lean.Server.Watchdog": { + "relative_path": "lib/lean/Lean/Server/Watchdog.olean", + "sha256": "25bdfc1d26766745f8123b35795cf75cc03b3d067d7fa917d746a89972fa1081" + }, + "Lean.Structure": { + "relative_path": "lib/lean/Lean/Structure.olean", + "sha256": "1cce03c390b480c9ccfdc752f482f5772f9e8191a89ac2f92dbb371293edce08" + }, + "Lean.SubExpr": { + "relative_path": "lib/lean/Lean/SubExpr.olean", + "sha256": "56463ec2e047a75bc9582f7cba3698476c0595b80ad936524481c97edc7c57bb" + }, + "Lean.Syntax": { + "relative_path": "lib/lean/Lean/Syntax.olean", + "sha256": "1257d7730ef2a59134c6d3a66b812bd28464a93e906d80aa684118a2a2f7e41c" + }, + "Lean.ToExpr": { + "relative_path": "lib/lean/Lean/ToExpr.olean", + "sha256": "681106024aa58dff7c5dbea53ef9b5e01c166267413e6603fb59f7e6ba4705e4" + }, + "Lean.ToLevel": { + "relative_path": "lib/lean/Lean/ToLevel.olean", + "sha256": "0f1039c2e1e3a4e024294fe8827de0b83809ef22d6f95141a20f17bfd57010ed" + }, + "Lean.Util": { + "relative_path": "lib/lean/Lean/Util.olean", + "sha256": "b3804c0b6fd4187caaa395cdbf07b210634c36b5862e5b01e99a334894041ac5" + }, + "Lean.Util.CollectAxioms": { + "relative_path": "lib/lean/Lean/Util/CollectAxioms.olean", + "sha256": "9dd674224d00ea6e9044e05e9022d0997ed842b0eceee5157da199ea523614d3" + }, + "Lean.Util.CollectFVars": { + "relative_path": "lib/lean/Lean/Util/CollectFVars.olean", + "sha256": "03e91ed3ea63c86fa4a74f01eb026cba7a3c7a9a66e911f3420388bf0a24b06a" + }, + "Lean.Util.CollectLevelMVars": { + "relative_path": "lib/lean/Lean/Util/CollectLevelMVars.olean", + "sha256": "ee4f7731ff6e32e49c472ecc660fe70b7e8e28a9fe3e787d95968fc334cdafb9" + }, + "Lean.Util.CollectLevelParams": { + "relative_path": "lib/lean/Lean/Util/CollectLevelParams.olean", + "sha256": "f57df1551f35babfbd25cd4d786d36ca1c1e668a7dc733f1e86a7768a898c70e" + }, + "Lean.Util.CollectMVars": { + "relative_path": "lib/lean/Lean/Util/CollectMVars.olean", + "sha256": "1c5fc9f6e4a37382985419959a6a9e223763b770d78238e26e3b2029565d201e" + }, + "Lean.Util.Diff": { + "relative_path": "lib/lean/Lean/Util/Diff.olean", + "sha256": "348b407f6ab6b4cea1c17189e88ad4449669db50724e85bf333a7cd6eef01f8f" + }, + "Lean.Util.FVarSubset": { + "relative_path": "lib/lean/Lean/Util/FVarSubset.olean", + "sha256": "931302f6ee0fa3706536bf4c786d63c55903ee608fcfee3a7e62a884230b4689" + }, + "Lean.Util.FileSetupInfo": { + "relative_path": "lib/lean/Lean/Util/FileSetupInfo.olean", + "sha256": "fedeae0565096639cc7344c39c75dcd51760d451cf9e3bae3f67403fa3301420" + }, + "Lean.Util.FindExpr": { + "relative_path": "lib/lean/Lean/Util/FindExpr.olean", + "sha256": "fc9f82a261866735ac5f16c64903d5cd7ce354a5d559359f69e14c066299b82a" + }, + "Lean.Util.FindLevelMVar": { + "relative_path": "lib/lean/Lean/Util/FindLevelMVar.olean", + "sha256": "efa86d730a224bac9f9559414945fb8e4480adf9bd5c6f614bc386ccef4b79a8" + }, + "Lean.Util.FindMVar": { + "relative_path": "lib/lean/Lean/Util/FindMVar.olean", + "sha256": "f7c599d6b22db24fed3d4572b254ef1f625abbf242dc21a376a123913fbeaadd" + }, + "Lean.Util.FoldConsts": { + "relative_path": "lib/lean/Lean/Util/FoldConsts.olean", + "sha256": "30a5b555e3da24c6138cda39b0ce2fdd2898549424f3f48a5f0ad5a84a6ad024" + }, + "Lean.Util.ForEachExpr": { + "relative_path": "lib/lean/Lean/Util/ForEachExpr.olean", + "sha256": "f9b3a9c2bd938afe1ed5bfe2cdaac38da291c1f9cbc3ef00c6d70fe18c48b38c" + }, + "Lean.Util.ForEachExprWhere": { + "relative_path": "lib/lean/Lean/Util/ForEachExprWhere.olean", + "sha256": "0f66cc8ae514f42e32e37450023f5325c013a5f3b31cc00643b305ec2050a813" + }, + "Lean.Util.HasConstCache": { + "relative_path": "lib/lean/Lean/Util/HasConstCache.olean", + "sha256": "997838afe6cdc2068b866980bbc2d9571e08821ec262b3f96b5d182bda4d1e41" + }, + "Lean.Util.Heartbeats": { + "relative_path": "lib/lean/Lean/Util/Heartbeats.olean", + "sha256": "ef98dc435a31b539200931e89b2d3f08bd6e7f689e00ec3522ab1210b86e672d" + }, + "Lean.Util.InstantiateLevelParams": { + "relative_path": "lib/lean/Lean/Util/InstantiateLevelParams.olean", + "sha256": "f05e8a234de5794988814cab37b89a021d6e869311cd4fa372ab4f9ee2124424" + }, + "Lean.Util.LakePath": { + "relative_path": "lib/lean/Lean/Util/LakePath.olean", + "sha256": "dd00ea5edef5aeaf9d68948e3616d4de5052a4ac3e2acb67126898567f3fdb1b" + }, + "Lean.Util.LeanOptions": { + "relative_path": "lib/lean/Lean/Util/LeanOptions.olean", + "sha256": "036d4d32660acc69d0fc60938f15ea9ffa1edc7440340197d5d09dfbf7482e02" + }, + "Lean.Util.MonadBacktrack": { + "relative_path": "lib/lean/Lean/Util/MonadBacktrack.olean", + "sha256": "3a721336f768b1bd3d838101868b17bdcddb936acbe232601080cb47dae6bdef" + }, + "Lean.Util.MonadCache": { + "relative_path": "lib/lean/Lean/Util/MonadCache.olean", + "sha256": "a49bf6318c1fa4b7642ee350d0a0adfd5c9c30edfdbf5375bb08c27e89b9d09e" + }, + "Lean.Util.NumApps": { + "relative_path": "lib/lean/Lean/Util/NumApps.olean", + "sha256": "5e9a3b8f61219d6eb81d5e68ebf9783b3e653e6d2cad90d35d7fa1edaf48498d" + }, + "Lean.Util.NumObjs": { + "relative_path": "lib/lean/Lean/Util/NumObjs.olean", + "sha256": "1b6dcd0400b21b6478e0690faf12be333ac561dee8edf34fa9d940e0536d9c8d" + }, + "Lean.Util.OccursCheck": { + "relative_path": "lib/lean/Lean/Util/OccursCheck.olean", + "sha256": "2105d2cafdc97780ed80d0c21d96e3a96eb8c5b27c6f478ad8f511ff1d307a39" + }, + "Lean.Util.PPExt": { + "relative_path": "lib/lean/Lean/Util/PPExt.olean", + "sha256": "a5c502d22177658a419a532038b821f28cef4fa7a32e3c2544726ddd0b019c5e" + }, + "Lean.Util.Path": { + "relative_path": "lib/lean/Lean/Util/Path.olean", + "sha256": "75e708dc5859e0639e7eceae77d508a187db39ccb6cab080143e8dd26d4a0304" + }, + "Lean.Util.Paths": { + "relative_path": "lib/lean/Lean/Util/Paths.olean", + "sha256": "74142ed1f2181bb4102c8a0f6e41d41a4c658232937fc597f4e4b1c2a183b1bc" + }, + "Lean.Util.Profile": { + "relative_path": "lib/lean/Lean/Util/Profile.olean", + "sha256": "f23c4842d954d119e83de4dde14edb34981d6994cbeea4de9c2ae381f17bf831" + }, + "Lean.Util.Profiler": { + "relative_path": "lib/lean/Lean/Util/Profiler.olean", + "sha256": "1e9a3eec7c150b0e9ca1c785861eabb3f9a9c35a00d105c513439ec840a7ccbc" + }, + "Lean.Util.PtrSet": { + "relative_path": "lib/lean/Lean/Util/PtrSet.olean", + "sha256": "231e789db2045483e7600fec9903afba50dbba3e95c8c925982e2c1ea71b8a17" + }, + "Lean.Util.RecDepth": { + "relative_path": "lib/lean/Lean/Util/RecDepth.olean", + "sha256": "ea7a31d5424201f52482f7a9bf6de3ed5e0f8e741c131b78551fc6ac47b6b357" + }, + "Lean.Util.Recognizers": { + "relative_path": "lib/lean/Lean/Util/Recognizers.olean", + "sha256": "6ce3043ebd4aeb4bf7e43914580fc3fc414635d908d152ac393c283e07d0c2ce" + }, + "Lean.Util.ReplaceExpr": { + "relative_path": "lib/lean/Lean/Util/ReplaceExpr.olean", + "sha256": "aee2465ad5bf2bba0f52b8a4ea4b444990bcf68e15c7e32c387f31fb5a4606ec" + }, + "Lean.Util.ReplaceLevel": { + "relative_path": "lib/lean/Lean/Util/ReplaceLevel.olean", + "sha256": "bbdf8e6a5aa715de21a3edea51c9e0798e40fdffbd4896d15a3202d19e21bc21" + }, + "Lean.Util.SCC": { + "relative_path": "lib/lean/Lean/Util/SCC.olean", + "sha256": "f4ecd7303b846253b6aa74f4910f1c97089995e20ea654d78572898ea5ab764a" + }, + "Lean.Util.SafeExponentiation": { + "relative_path": "lib/lean/Lean/Util/SafeExponentiation.olean", + "sha256": "6ac2c719d74ffd8ec932fed7ea38541bb0bd64b1db68c15e143f1b31b7905a03" + }, + "Lean.Util.SearchPath": { + "relative_path": "lib/lean/Lean/Util/SearchPath.olean", + "sha256": "5c541f16a00ce65845346ff39f3e52602ba24873f9143b696ad31a35d0d0b174" + }, + "Lean.Util.ShareCommon": { + "relative_path": "lib/lean/Lean/Util/ShareCommon.olean", + "sha256": "041136336e252a66b1e09dbb0509423603f964469b9f41f34bb45cb47319683a" + }, + "Lean.Util.Sorry": { + "relative_path": "lib/lean/Lean/Util/Sorry.olean", + "sha256": "dc16c4717cb1b982328f48069d111d46ec937d63bf7648c94811c2ac7f8978a5" + }, + "Lean.Util.SortExprs": { + "relative_path": "lib/lean/Lean/Util/SortExprs.olean", + "sha256": "45a472f4dab7a0b1a22a2d5b07eac4e460c7a4471d49646f62e2d97d920faf6e" + }, + "Lean.Util.TestExtern": { + "relative_path": "lib/lean/Lean/Util/TestExtern.olean", + "sha256": "0c45aa686987702907d541dbe624dfb3b8c8389586d732fa05c9b86a53a96800" + }, + "Lean.Util.Trace": { + "relative_path": "lib/lean/Lean/Util/Trace.olean", + "sha256": "40e261ba920c89ca7a7573bfc699a3ac1e20983625025e2fc77a3aa8181a2c8f" + }, + "Lean.Widget": { + "relative_path": "lib/lean/Lean/Widget.olean", + "sha256": "82d3aaf72aaee748640ab3d5857f71623623455d4b4c7ac359f0f4e5e39a49f9" + }, + "Lean.Widget.Basic": { + "relative_path": "lib/lean/Lean/Widget/Basic.olean", + "sha256": "7b47ae225c065d669da84ca522e2dceb9a577e4bd7474d7377cf94d189a14ed9" + }, + "Lean.Widget.Diff": { + "relative_path": "lib/lean/Lean/Widget/Diff.olean", + "sha256": "6803e1c1d4d7de80fabd38cce68ecdabef3888f104d5b5bb17456a41a103ed6f" + }, + "Lean.Widget.InteractiveCode": { + "relative_path": "lib/lean/Lean/Widget/InteractiveCode.olean", + "sha256": "08dd8d5166eba1216188ec5a5b791c2e571805398fad6a4f0d1793026f063f54" + }, + "Lean.Widget.InteractiveDiagnostic": { + "relative_path": "lib/lean/Lean/Widget/InteractiveDiagnostic.olean", + "sha256": "a57b624487c0509b52919bf93ca49fd5006669cd87a28d7d1d6df05b7c121368" + }, + "Lean.Widget.InteractiveGoal": { + "relative_path": "lib/lean/Lean/Widget/InteractiveGoal.olean", + "sha256": "fe6f3299cefd00d81053c19c7a68a9140dd3c1199581807d18bc10212836b5b1" + }, + "Lean.Widget.TaggedText": { + "relative_path": "lib/lean/Lean/Widget/TaggedText.olean", + "sha256": "2231b307e81af9a860c445c61019110b50b2f7a147b20d4eff3a7aca896a495e" + }, + "Lean.Widget.Types": { + "relative_path": "lib/lean/Lean/Widget/Types.olean", + "sha256": "ec95be52006e362cdbab66493e159108d6b2803f7febb6f763d3e6ab58350a40" + }, + "Lean.Widget.UserWidget": { + "relative_path": "lib/lean/Lean/Widget/UserWidget.olean", + "sha256": "0e76215569ef9ba42148916c778a855b0eda47c384ffe95f40848401d3f7e77a" + }, + "Std": { + "relative_path": "lib/lean/Std.olean", + "sha256": "7d3771da25b893da62564bf8198487ff28f01af5cbd410be88d493a4921b2bb1" + }, + "Std.Classes.Ord": { + "relative_path": "lib/lean/Std/Classes/Ord.olean", + "sha256": "d951a4e6a043afe223eec3c1fc4ac05f4da95e923d7f9fa7438ccf1c4c5894e9" + }, + "Std.Data": { + "relative_path": "lib/lean/Std/Data.olean", + "sha256": "0c7214cfc515a6bd7d993a5a036a749d927911c61074e6f000b2f6e5c5e68437" + }, + "Std.Data.DHashMap": { + "relative_path": "lib/lean/Std/Data/DHashMap.olean", + "sha256": "82829a319d1dbc479d69cbeded2541fb6d4bea621843bcfb621dcddf66e3df4a" + }, + "Std.Data.DHashMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/DHashMap/AdditionalOperations.olean", + "sha256": "dcda48b215964eeb7adfdd6d8c898750cfdde669285b7e53559e844747be2e4f" + }, + "Std.Data.DHashMap.Basic": { + "relative_path": "lib/lean/Std/Data/DHashMap/Basic.olean", + "sha256": "3edd8593c538aa619f7a6a49b1201f895b2e195732067e9804cd1ec746ae0230" + }, + "Std.Data.DHashMap.Internal.AssocList.Basic": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Basic.olean", + "sha256": "cde6580d4017820217ba306c2850560e6c3820a22675b795bab7deee58fae39a" + }, + "Std.Data.DHashMap.Internal.AssocList.Lemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/AssocList/Lemmas.olean", + "sha256": "89bb1625f83532972c2508e241727bd158ed8630437449d6dfb2409004029cca" + }, + "Std.Data.DHashMap.Internal.Defs": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Defs.olean", + "sha256": "b6789918a75b94e20a471fc1249196389b61a7bca005cb6e11868b9b2e0b2050" + }, + "Std.Data.DHashMap.Internal.HashesTo": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/HashesTo.olean", + "sha256": "df5a76c22a9d30d6067466a54454ffafb1d7a268ff2327e10d274d4b86bcb787" + }, + "Std.Data.DHashMap.Internal.Index": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Index.olean", + "sha256": "ca4d3761d5291eccc1f8238dafbe210fa5666c54a0a42c3e9b51acdcbe9d4900" + }, + "Std.Data.DHashMap.Internal.Model": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Model.olean", + "sha256": "dd3b5266f90bdc5e4cc8c5e9c1b65222671aaa830a5a23508f9fdb00fa6111c3" + }, + "Std.Data.DHashMap.Internal.Raw": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/Raw.olean", + "sha256": "ab20c7d8f702c86de6cce3e18141f1297dea8d51a579460b0ddab9e278daf908" + }, + "Std.Data.DHashMap.Internal.RawLemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/RawLemmas.olean", + "sha256": "aa891b7b6476ead8295065dcd7df85e16c40e95a8a48c433d1e0c6ff8f58e9a7" + }, + "Std.Data.DHashMap.Internal.WF": { + "relative_path": "lib/lean/Std/Data/DHashMap/Internal/WF.olean", + "sha256": "0d02c631912fd443890dd882c9035af450a64ded829c5613e29c6ad6d8690538" + }, + "Std.Data.DHashMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/Lemmas.olean", + "sha256": "f5191f02349eb72c1ddb45074f9239912d9cd008a48a6cbabd76b2469d28d197" + }, + "Std.Data.DHashMap.Raw": { + "relative_path": "lib/lean/Std/Data/DHashMap/Raw.olean", + "sha256": "5ff8a7568a967e563bba428926cc128806c61ef2ecce021358984a45cff4c308" + }, + "Std.Data.DHashMap.RawDef": { + "relative_path": "lib/lean/Std/Data/DHashMap/RawDef.olean", + "sha256": "98e9e12f08790541143b32cfdaec3d0289209b1e770774dc01345116a7dddca4" + }, + "Std.Data.DHashMap.RawLemmas": { + "relative_path": "lib/lean/Std/Data/DHashMap/RawLemmas.olean", + "sha256": "514c964fac6f063724169db30add357a674ca243957dfa221e30430c26f06c92" + }, + "Std.Data.DTreeMap": { + "relative_path": "lib/lean/Std/Data/DTreeMap.olean", + "sha256": "51e3386cf7ba0a9f270c3a6d44af2ef5f6bac8fcffe8458cb7d3bba2edf610aa" + }, + "Std.Data.DTreeMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/DTreeMap/AdditionalOperations.olean", + "sha256": "a20b5c57a0db704748a2e2926dfa4d2cf1e4ddaefcc2245688970941c5ca8429" + }, + "Std.Data.DTreeMap.Basic": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Basic.olean", + "sha256": "26808eeb3d7d1e129af3a70fe13001b79dc74b18c7b406cb1373c7de98f62f56" + }, + "Std.Data.DTreeMap.Internal.Balanced": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Balanced.olean", + "sha256": "485264c582ccaaf76b6796dd881ccd1f6f61012f5d0c722fde5bd9a7b4310c70" + }, + "Std.Data.DTreeMap.Internal.Balancing": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Balancing.olean", + "sha256": "5263f1223026803115af0abbeeffdea7754796f215e6713aefc40c839b8353c1" + }, + "Std.Data.DTreeMap.Internal.Cell": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Cell.olean", + "sha256": "16fadb10f9bf8b6f4f20ec627775bdb827ff1f12c66b8e5f97c7e14b4a63ce98" + }, + "Std.Data.DTreeMap.Internal.Def": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Def.olean", + "sha256": "ad1d1e858fb304c03404a3003afefa2ab63634f240352448dbbe000fbc280ae7" + }, + "Std.Data.DTreeMap.Internal.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Lemmas.olean", + "sha256": "86f93dba7c263b8817d9a6e568d2a298b223b1dcf7a3bf63a21e04485d1e702e" + }, + "Std.Data.DTreeMap.Internal.Model": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Model.olean", + "sha256": "190a424ea72373859e33b93057f74fddfff1901c99020758c3b2a071893edcca" + }, + "Std.Data.DTreeMap.Internal.Operations": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Operations.olean", + "sha256": "02e3f14395f2e036d817076b3e901b7d186bd39c8b9e7204a1684faac1b5eaca" + }, + "Std.Data.DTreeMap.Internal.Ordered": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Ordered.olean", + "sha256": "bfd736cf4717c6dfd91e4764c030a2e35d7d80f24532ceccbb56924be30d3603" + }, + "Std.Data.DTreeMap.Internal.Queries": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/Queries.olean", + "sha256": "4fb2bc063203c87f9db29252321a80602d0a7265647778abc9d22aaba5acbee7" + }, + "Std.Data.DTreeMap.Internal.WF.Defs": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Defs.olean", + "sha256": "899b439766bf2c13fba7b5ebfa6da9110b2e9f6e9ad9125c721d339332792432" + }, + "Std.Data.DTreeMap.Internal.WF.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Internal/WF/Lemmas.olean", + "sha256": "b6660199d8eaf0aaa0227cc92ef439c43914ff5f193983cb236d761212481a2a" + }, + "Std.Data.DTreeMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Lemmas.olean", + "sha256": "8f13b8ea4484f0112ac26021f999437da815203047e8d6dd398b3460616466bb" + }, + "Std.Data.DTreeMap.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/DTreeMap/Raw/Basic.olean", + "sha256": "d7ac0f19bdbd8fc3fbdeb86e07d5359234da8e0ead67247fb552613579747f6c" + }, + "Std.Data.HashMap": { + "relative_path": "lib/lean/Std/Data/HashMap.olean", + "sha256": "99aff9518169b47e1e93af220fb0526ff2a5ecaf538ff1bdd2962b6f2c8d4758" + }, + "Std.Data.HashMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/HashMap/AdditionalOperations.olean", + "sha256": "f7122016e852683cbe4b78252a5a0d334e31d8c583634068600988194a135753" + }, + "Std.Data.HashMap.Basic": { + "relative_path": "lib/lean/Std/Data/HashMap/Basic.olean", + "sha256": "6f76031eeeaa6d43db6e9c3a77c12f7811a80ac7d92b1538bd1b03c99e0588f6" + }, + "Std.Data.HashMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/HashMap/Lemmas.olean", + "sha256": "13da5f44c528a875968ebcab85fafb5cfc854b7f54fd4880ae6fbec2c8dd70d6" + }, + "Std.Data.HashMap.Raw": { + "relative_path": "lib/lean/Std/Data/HashMap/Raw.olean", + "sha256": "e22fdbb83c3274c85d0a292a3810c6408d134cf0d5e8bc0329f50777aee3e3f3" + }, + "Std.Data.HashMap.RawLemmas": { + "relative_path": "lib/lean/Std/Data/HashMap/RawLemmas.olean", + "sha256": "0a3c4d3b8e8d5ab3006148f6e227e5482da7199f8865c0c8dc762d07a13c71a8" + }, + "Std.Data.HashSet": { + "relative_path": "lib/lean/Std/Data/HashSet.olean", + "sha256": "ae45358a15acbf4ac5609305ab80d9ca42fa22cb4589f3c48c2a94a507250451" + }, + "Std.Data.HashSet.Basic": { + "relative_path": "lib/lean/Std/Data/HashSet/Basic.olean", + "sha256": "8bae54c3695a9aa1f51b76043d32ebbae9123b1a155605c54c1be2a899ce3385" + }, + "Std.Data.HashSet.Lemmas": { + "relative_path": "lib/lean/Std/Data/HashSet/Lemmas.olean", + "sha256": "29883ee4a5a8aceeef42dd000f1a3d682416b3668289b05afbb86cf3dbe7ed72" + }, + "Std.Data.HashSet.Raw": { + "relative_path": "lib/lean/Std/Data/HashSet/Raw.olean", + "sha256": "dc892a38a4976c064458b561027640cb3343c9661141c532c465f24bb635271d" + }, + "Std.Data.HashSet.RawLemmas": { + "relative_path": "lib/lean/Std/Data/HashSet/RawLemmas.olean", + "sha256": "ad52a319fb705c08ffd691126d42ee63e0e6a6caeb828114828cc2fe466f8db9" + }, + "Std.Data.Internal.Cut": { + "relative_path": "lib/lean/Std/Data/Internal/Cut.olean", + "sha256": "16e746f9da7b0e74567b1656a7e3f99cafc699acc54faed11bbe17a02d801060" + }, + "Std.Data.Internal.List.Associative": { + "relative_path": "lib/lean/Std/Data/Internal/List/Associative.olean", + "sha256": "fec662ce7c583a3d835d612b39ec478a6153c06e3b7de30a537cf6895f5bb093" + }, + "Std.Data.Internal.List.Defs": { + "relative_path": "lib/lean/Std/Data/Internal/List/Defs.olean", + "sha256": "56e8ec040898820fa1f1b9d807be6c96e4c44812b61c37b29ba4eb92199dbbc4" + }, + "Std.Data.TreeMap": { + "relative_path": "lib/lean/Std/Data/TreeMap.olean", + "sha256": "a1acd79ea550bcbeb8803a663d203d65c2ec5f3c528e1d3b20e6d84bba1f5818" + }, + "Std.Data.TreeMap.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/TreeMap/AdditionalOperations.olean", + "sha256": "7ff677628c427286ffa273bb5e733ba2b3c400ba4ac199377d8f354740bd90d5" + }, + "Std.Data.TreeMap.Basic": { + "relative_path": "lib/lean/Std/Data/TreeMap/Basic.olean", + "sha256": "01d1578d10e52b69cfa9a2ebc0dbbb16dd36a786deee2bdf44129b2672f67755" + }, + "Std.Data.TreeMap.Lemmas": { + "relative_path": "lib/lean/Std/Data/TreeMap/Lemmas.olean", + "sha256": "c6b1f9d219326bf24700910e14066001120a278f007001bbf2a32dedd1af4006" + }, + "Std.Data.TreeMap.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/TreeMap/Raw/Basic.olean", + "sha256": "bc2fb5d7aa288ceb2d373f3c6a66c016a439cd1eb5560ba2a641e835064c833e" + }, + "Std.Data.TreeSet": { + "relative_path": "lib/lean/Std/Data/TreeSet.olean", + "sha256": "14078e4b78360b5431a4232dc911486455591bff1a3fad55f9155ae8c2ad7cac" + }, + "Std.Data.TreeSet.AdditionalOperations": { + "relative_path": "lib/lean/Std/Data/TreeSet/AdditionalOperations.olean", + "sha256": "86a8774587ec420050092ce6ba115aa9d379c59b491f55c815c062fdff15ce73" + }, + "Std.Data.TreeSet.Basic": { + "relative_path": "lib/lean/Std/Data/TreeSet/Basic.olean", + "sha256": "8f725039367c3acfe7a9de41011ce1bf66cb375fb16a0b4468d414c2f0ed5fc6" + }, + "Std.Data.TreeSet.Lemmas": { + "relative_path": "lib/lean/Std/Data/TreeSet/Lemmas.olean", + "sha256": "c436c982509e245de849ae7ca0a437b7f08eed26cd7a3eccc926763acd3fe9fe" + }, + "Std.Data.TreeSet.Raw.Basic": { + "relative_path": "lib/lean/Std/Data/TreeSet/Raw/Basic.olean", + "sha256": "e970f9894439ef66418424f9d769c9e76de5ed0a6443c90dd821b482d715d015" + }, + "Std.Internal": { + "relative_path": "lib/lean/Std/Internal.olean", + "sha256": "450df0e4fd6e36bd632bccad2663e04b615dbba865e59de53815dd54bc5d3c1f" + }, + "Std.Internal.Async": { + "relative_path": "lib/lean/Std/Internal/Async.olean", + "sha256": "01ffdfd1f0410911338f8ef8b7e5f403d875b1a38ed01eac1953cd9c1659e3eb" + }, + "Std.Internal.Async.Basic": { + "relative_path": "lib/lean/Std/Internal/Async/Basic.olean", + "sha256": "77e5e714a1a50a1c66d738574d61b94729fa505d928f4041b479220c35f926d2" + }, + "Std.Internal.Async.TCP": { + "relative_path": "lib/lean/Std/Internal/Async/TCP.olean", + "sha256": "b8d4d89acab2bbb45c8f0ae41f0d43a9d1978efdbbf3cce9d21a8adbe977fbf2" + }, + "Std.Internal.Async.Timer": { + "relative_path": "lib/lean/Std/Internal/Async/Timer.olean", + "sha256": "df2a28402222a5529fe6c5d506b96d8b1a11a9a5722456590e77be97fe7bd59f" + }, + "Std.Internal.Async.UDP": { + "relative_path": "lib/lean/Std/Internal/Async/UDP.olean", + "sha256": "42aaaef54fd0324c3160d18901df6ab67d12c1392a5f7f79764e4b8ccdabef84" + }, + "Std.Internal.Parsec": { + "relative_path": "lib/lean/Std/Internal/Parsec.olean", + "sha256": "847cdbecf06faf5fc1ec0a8edbda87e56cae864215c3e5b0794e4487e52991e5" + }, + "Std.Internal.Parsec.Basic": { + "relative_path": "lib/lean/Std/Internal/Parsec/Basic.olean", + "sha256": "5043a60429010c81f150397f937633e38e59a4ebb0fedd362a3c4326d4c9e70c" + }, + "Std.Internal.Parsec.ByteArray": { + "relative_path": "lib/lean/Std/Internal/Parsec/ByteArray.olean", + "sha256": "b83f1320328c2ad431534ac41512842f4d99059c8ffce50cfad5c323f5d05bcb" + }, + "Std.Internal.Parsec.String": { + "relative_path": "lib/lean/Std/Internal/Parsec/String.olean", + "sha256": "d8fb53b268a2d7ca6b26a14028a6e2a396063d3c747373aca64f18bdafbcdd82" + }, + "Std.Internal.Rat": { + "relative_path": "lib/lean/Std/Internal/Rat.olean", + "sha256": "63e1219fe06b26b0022abcebc49b641a8726d1ffcb43650b6afcb61af71ef85e" + }, + "Std.Internal.UV": { + "relative_path": "lib/lean/Std/Internal/UV.olean", + "sha256": "510f7cfab3bf9547fe3bce0dd31453b8521ed3b7b25beeb16ee88bb088c90e60" + }, + "Std.Internal.UV.Loop": { + "relative_path": "lib/lean/Std/Internal/UV/Loop.olean", + "sha256": "732dc39b26fbc6027819191475f9aade211b5995be9036bf0babd80d2740d09e" + }, + "Std.Internal.UV.TCP": { + "relative_path": "lib/lean/Std/Internal/UV/TCP.olean", + "sha256": "dadd785a07060659ba22f37fcb6e17a06af3b6140d200e7d8f223ae7aaf928ad" + }, + "Std.Internal.UV.Timer": { + "relative_path": "lib/lean/Std/Internal/UV/Timer.olean", + "sha256": "57cee1e20bf5d037bcf6afe9720488ee00720e2deb2ce05d0445d4e097fc27b1" + }, + "Std.Internal.UV.UDP": { + "relative_path": "lib/lean/Std/Internal/UV/UDP.olean", + "sha256": "29d41d16510671c81a1df5b46e75f8c61c0ecce2ee5b35e53737bdc724022b2e" + }, + "Std.Net": { + "relative_path": "lib/lean/Std/Net.olean", + "sha256": "4c3e86bee81a4336a0aa64a3be9467a20b8b738bd1a8924ee4df82b980a0e4a2" + }, + "Std.Net.Addr": { + "relative_path": "lib/lean/Std/Net/Addr.olean", + "sha256": "21a68252d88ccc4e33691b2cab7aef5cc7cc8881c4e7a00e2154c4db8635492d" + }, + "Std.Sat": { + "relative_path": "lib/lean/Std/Sat.olean", + "sha256": "fcc29fb616396ddc2d3047d9b5c2f8dd3ad6239d727e06edfa2273e11f22109c" + }, + "Std.Sat.AIG": { + "relative_path": "lib/lean/Std/Sat/AIG.olean", + "sha256": "7c6aea2cf4f55d3ea5b3b4ae186869fcd416cb24fc5b1c797bf2aa511ced7207" + }, + "Std.Sat.AIG.Basic": { + "relative_path": "lib/lean/Std/Sat/AIG/Basic.olean", + "sha256": "97590c68ccbef54da03f6ea927368d999b560f594840a2c2c3899e52602a2a19" + }, + "Std.Sat.AIG.CNF": { + "relative_path": "lib/lean/Std/Sat/AIG/CNF.olean", + "sha256": "38e7324f561c93510b5b42466fc3b60be8372a46e0b872a45678fd6dc40c8495" + }, + "Std.Sat.AIG.Cached": { + "relative_path": "lib/lean/Std/Sat/AIG/Cached.olean", + "sha256": "f9b8e7536aaa9f2663fb19cbfddd1da6c0c9d1035b79ed5f71acea3ed76a913f" + }, + "Std.Sat.AIG.CachedGates": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedGates.olean", + "sha256": "a9fba0492584b3e3e537f181e626be94d5ff4d4f7cdfb6193d0ebfa59619fb03" + }, + "Std.Sat.AIG.CachedGatesLemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedGatesLemmas.olean", + "sha256": "e7637f2f0f2df05851138dc94f305c976aca8fbd121f648afae1b1be75edf072" + }, + "Std.Sat.AIG.CachedLemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/CachedLemmas.olean", + "sha256": "4e8c65e9bc960950ea123ee30c9434b1e7a31955db5c6b118b5f6d1bf91b4151" + }, + "Std.Sat.AIG.If": { + "relative_path": "lib/lean/Std/Sat/AIG/If.olean", + "sha256": "0a976606263c24d96f678d34322b1172ee3ae1c1f50c9bc25274411b99ddbb21" + }, + "Std.Sat.AIG.LawfulOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/LawfulOperator.olean", + "sha256": "c8467c1aee8523a9b728ccf79988145304cada06f1da7eb80324db331aec8728" + }, + "Std.Sat.AIG.LawfulVecOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/LawfulVecOperator.olean", + "sha256": "2bcfabf0755288b3c3099a16e615e0e7e474c9b48e705ebee28137a46c4c6768" + }, + "Std.Sat.AIG.Lemmas": { + "relative_path": "lib/lean/Std/Sat/AIG/Lemmas.olean", + "sha256": "0056f8de120614c48889fe5157b0fa5eb4e5caa87c1300a46d6f412268baf65d" + }, + "Std.Sat.AIG.RefVec": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVec.olean", + "sha256": "e8de7999a97a5390370aec10715a77d3abaf292a7df37a584c06e706458284ae" + }, + "Std.Sat.AIG.RefVecOperator": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator.olean", + "sha256": "c07b62713579424613487ed5f40318b44cd5a30036959d23e9c7a39256c9474f" + }, + "Std.Sat.AIG.RefVecOperator.Fold": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Fold.olean", + "sha256": "8c65d0c2a25e424866314efd53a4edc08c2cd9da55edb76034538969fa3db5bc" + }, + "Std.Sat.AIG.RefVecOperator.Map": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Map.olean", + "sha256": "569cee3ddeb7b1b314354d0f051052bc4d21919d3948c06eeaba5da15f9dac96" + }, + "Std.Sat.AIG.RefVecOperator.Zip": { + "relative_path": "lib/lean/Std/Sat/AIG/RefVecOperator/Zip.olean", + "sha256": "94244a0a8f0ce753f93b64831b56577cd9b8d68f9131b278281b77a3f2d43d44" + }, + "Std.Sat.AIG.Relabel": { + "relative_path": "lib/lean/Std/Sat/AIG/Relabel.olean", + "sha256": "fbdc72b958646b6206f8fd36cac01472e075dc69705f33947bbbef6614b6aa8b" + }, + "Std.Sat.AIG.RelabelNat": { + "relative_path": "lib/lean/Std/Sat/AIG/RelabelNat.olean", + "sha256": "8d7e0ea32786d8ce69c8605df88c666dbf8dee641c7945fde40e302ce7051a9d" + }, + "Std.Sat.CNF": { + "relative_path": "lib/lean/Std/Sat/CNF.olean", + "sha256": "a7ad1ae81e0305e03e2b6f3827101cde4cf4da0b64a59b3a25c038c4661ddc77" + }, + "Std.Sat.CNF.Basic": { + "relative_path": "lib/lean/Std/Sat/CNF/Basic.olean", + "sha256": "9fd3c6545ed9a1cb8b606df1749d7e40eb4eac6932fd19ad0efbbaaef98534d4" + }, + "Std.Sat.CNF.Dimacs": { + "relative_path": "lib/lean/Std/Sat/CNF/Dimacs.olean", + "sha256": "d35723222970cd0c95eccee2d1c8d94aef51ab955c1b8f35eb024fc395f664b4" + }, + "Std.Sat.CNF.Literal": { + "relative_path": "lib/lean/Std/Sat/CNF/Literal.olean", + "sha256": "86f2a80fe2c28b8e831989e13154f772a51fe820bca3ea61c5a542a56b0eef6d" + }, + "Std.Sat.CNF.Relabel": { + "relative_path": "lib/lean/Std/Sat/CNF/Relabel.olean", + "sha256": "e9bb76081b5ecf50ee4b6dd88e99f9cf405dc77574772c8645fd5f43d4310ec3" + }, + "Std.Sat.CNF.RelabelFin": { + "relative_path": "lib/lean/Std/Sat/CNF/RelabelFin.olean", + "sha256": "5b23bd94880be12c59a33437f57c82873234d547a0085a29c6dc4ca37f304ab2" + }, + "Std.Sync": { + "relative_path": "lib/lean/Std/Sync.olean", + "sha256": "6b122caecb73d049b18ea82b184696b04898758dea48f62c7e8b0ec17068c34f" + }, + "Std.Sync.Barrier": { + "relative_path": "lib/lean/Std/Sync/Barrier.olean", + "sha256": "0865e927b2d5c74eb1e762ef6043b19db015a3f7a16997392bdbe3405616c9e6" + }, + "Std.Sync.Basic": { + "relative_path": "lib/lean/Std/Sync/Basic.olean", + "sha256": "0ab37aae226de3c3c249e48eb99348220fd9239db043e8e70b00491ca7df6ffb" + }, + "Std.Sync.Channel": { + "relative_path": "lib/lean/Std/Sync/Channel.olean", + "sha256": "d263a7b5e81f7d062701d56c2f2940ec728e0b45d42ae29ac7ef5ad174b17a0f" + }, + "Std.Sync.Mutex": { + "relative_path": "lib/lean/Std/Sync/Mutex.olean", + "sha256": "28b1da9b8ad2e7873573ef3a394c20fbb1483b145dea927e22ae760913dfd30c" + }, + "Std.Sync.RecursiveMutex": { + "relative_path": "lib/lean/Std/Sync/RecursiveMutex.olean", + "sha256": "e270bb327da588a077b986c6683149f93c99ed2e43f2b80cdc79bf3255118fe5" + }, + "Std.Tactic": { + "relative_path": "lib/lean/Std/Tactic.olean", + "sha256": "bc4cb70f826910d0d63d5bb519966d715681e8fe8fb73913796d9c51c8530d7d" + }, + "Std.Tactic.BVDecide": { + "relative_path": "lib/lean/Std/Tactic/BVDecide.olean", + "sha256": "ec2db6253a2c5adbe13b53fdf97893e62022706a3a1604ade21af796ae949a17" + }, + "Std.Tactic.BVDecide.Bitblast": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast.olean", + "sha256": "faef1612ce3f38d3fa7978cf6b303d9876bbd43837dab7bfc0d7df30a42a1f86" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr.olean", + "sha256": "36c4f0fd074cd62290da4cd5d0dd25b253108e7b37927836a2a68e24cbc62611" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Basic.olean", + "sha256": "3fbf55b92e7fa7459b5626803a5c28693f10ae22bcc07dd0bbd5f9e52ddd5fc4" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit.olean", + "sha256": "dc870f512d9db277c5e04837974578471b7aa8b6d7cd20c2e349c9f55776fde1" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl.olean", + "sha256": "2bc70c17d6a23ed6d2b67e0fa0c46a2cde4b41fa6aec824dc64f609a81f8076b" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Carry.olean", + "sha256": "28690113394104f6b0bf446e71254522b38e370ad8b4c48d2643c3c251f117c4" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Const.olean", + "sha256": "f831b1544b66b6c04562548d8ee3cd406faed9171e989001d235ca22489d93de" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Expr.olean", + "sha256": "00399f76c92cefb3439614ef294998f337e72995b6279c7f3f57be5a182f3952" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Add.olean", + "sha256": "9fc172f017a8e08b3d373edb60be3aba9e3d82854acee27bb757e2052b7a073f" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Append.olean", + "sha256": "ba59db26788faeb05b026dd06ba5ddb8b39cb9169110413fa6ad5d65a1782f43" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Eq.olean", + "sha256": "296f54c53ddf18f21dd6dbc6e279ba7256b944e35ed130570288d2fbc1bbafd3" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Extract.olean", + "sha256": "4391a259589f6be7008648b4ab9eef743dc2b9a74f0f7dd4d631d534b8811e17" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/GetLsbD.olean", + "sha256": "c87ee1a5d918eeda72930bbcf4889d9402a09bfe286b25012b06efac778dafbf" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Mul.olean", + "sha256": "69116d9ffc41a4f37932d8cb3b4cea6592b9bda6f583df045b0f30ae0ec4a878" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Neg.olean", + "sha256": "1c3439af37c32110c822bfee7afdf8b82289219f223e4475a61a2930876c270d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Not.olean", + "sha256": "bdae571ecb63fcd2e404c549d0233645f1d49daa257b854c03fdc672b11f25fe" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Replicate.olean", + "sha256": "6be36fe5e846df460b9cafdce7ce00525a16032b0f9957ef269429e4bc3235ce" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateLeft.olean", + "sha256": "2af3d46c89c1184b87d0499f08ae1364ede6b4d45a682ecc84a646c6ff37b590" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/RotateRight.olean", + "sha256": "59df5f0bdf0ab63f1d3a70c1ec428b51cd4d272aedd17ff6e69a47c8043eeb90" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftLeft.olean", + "sha256": "1c55bdc3550f4476aad8e2aabd64211d69c8993514758e2af3cc2251769b138e" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ShiftRight.olean", + "sha256": "f13b326a06e1000c0515520d0f4899e1aff23420f0e0e6ac5bba48a7a2061741" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Sub.olean", + "sha256": "102946d64852967c3f451a662c10e0a548bec046e621e551b7dc467e4a0a2d7e" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Udiv.olean", + "sha256": "5f58293f58319935148d7a2bc68ad221ce9f5af0083862d72aece51381358100" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Ult.olean", + "sha256": "5d0b577707c12577db272d62533ff29b2c37eca1ea425df4aaf104e74082ce1d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/Umod.olean", + "sha256": "0557dd76c0b555d978d97d7f04bc178ebb786d428871e4dd3cd73445f8bd2c39" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Operations/ZeroExtend.olean", + "sha256": "81ba89dd877e8f5ecb4d79795d720bff671a1c226354759b28fab162f38e46ff" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Pred.olean", + "sha256": "ebc829c16a69ba4601c7173f03eec5532020c0cff7ae92cd6dbcefd0368c2697" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Substructure.olean", + "sha256": "a4303ebf7a2e9d22270c2838e6240c06b563518adb9d4137349db1777b96ba86" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Impl/Var.olean", + "sha256": "3a8c2f39f7bf1f389bbd88e0e960d34ecf4b7af474a15d3669a397fe63a3b687" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas.olean", + "sha256": "d67ad63ce049fe122cf9772ed2782555c6616ac326f67426e153f6cd5f5f31ea" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Basic.olean", + "sha256": "308ad2bec762bc6ba6dd20c8a59466369dff6f12baed0014502ceb9af81f9128" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Carry.olean", + "sha256": "c594d47b6dd7831dc6fbf18f337e4beb8cc317596d4da513c74cdd590b2aaa82" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Const.olean", + "sha256": "0e83560f33741e683d83de2c88d3b9bea126b818d4f9b947b6e2e60f3273793a" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Expr.olean", + "sha256": "f4afff7bfa61967afcddcef49102e8aa6abfb46ac719f45fae9b2929995939df" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Add.olean", + "sha256": "57f9283128ba0708949930c0919ecadc22ec7b9d7e6b2dcdd7fad92a736afe0d" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Append.olean", + "sha256": "35d396442771affa7630a0347396755620f9d042e8d489514dbefa2e5f3bd3ef" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Eq.olean", + "sha256": "61ab83020b62ecea43b39fb36d24b2c6264f101c300bc53a020e29ac5cf23202" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Extract.olean", + "sha256": "561125bbfaf3f343d17e25d37d77e43cfd0eaf6e21e0017cc9112929162d6628" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/GetLsbD.olean", + "sha256": "cc8b989993b821ea578bb842b8da6c80522df6826b6d01238ca5adb568e449ac" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Mul.olean", + "sha256": "d3072d202bf75c36371af08a4299d2982ad51392353d92d5011357964e3cd384" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Neg.olean", + "sha256": "2be5439ac28922644312c8f8299059f81e58c79741d3a681a8a14a83457649ab" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Not.olean", + "sha256": "5b894fa82377d826b231e52d38987bf71fc1b10a92a7955fd18d9e5e5ebfe7ec" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Replicate.olean", + "sha256": "b2ac78762a87a6575421fda19f6576adf93e93f0b1af4b0ce49f55b8e9064463" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateLeft.olean", + "sha256": "0c5587d74b82923fd948c50d3da937bab12b86ec827d5e560c82b35bfa5c68fa" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/RotateRight.olean", + "sha256": "b95d38b7d0aabf70cb06123400e6ba0b94fd6073228b0eb5f55ab97d4428938a" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftLeft.olean", + "sha256": "789048c3011f067a8b8fba24630807fa03ce445f9e3dfac8c3528a4456603265" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ShiftRight.olean", + "sha256": "3dcc31a71f38e23ac8977a6e457302b32f5bcebde968012f3c33719e6b9c14f3" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Sub.olean", + "sha256": "b5f8825d43310fb7f7333af20149f3064337396bafef7011d8af55c7f90380a5" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Udiv.olean", + "sha256": "8d9ff31e861a653c4998376235a1bfd1dcf760f05e1500f9867180cefd020d8b" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Ult.olean", + "sha256": "10d1d3835811dde10bb29ad96b6c897780d8560198b0d04f28d1c3e4f4be1205" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/Umod.olean", + "sha256": "41ca8e8480c53c66991bf6dd267aa6bcd8d7c347942dec93d11b85f8d7224555" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Operations/ZeroExtend.olean", + "sha256": "b2d68c645229bcfff4c1cb5d536e6acc7cb924ee954f9632198d5039280cd446" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Pred.olean", + "sha256": "76828daa75f4568048da7ae525f1da9927112b9ea96ec22385387e2dcc0d1cbe" + }, + "Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BVExpr/Circuit/Lemmas/Var.olean", + "sha256": "1a87afbf4654899ff46aed23db3f6ee24775b3113f551d4b1fb1e4e055b4968b" + }, + "Std.Tactic.BVDecide.Bitblast.BoolExpr": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr.olean", + "sha256": "3ab631e587fb4f4a5fc155f91d705d3ac544f98c75b22313db962ae0fcd9ba26" + }, + "Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Bitblast/BoolExpr/Basic.olean", + "sha256": "d441ce6550ac5d66fa7fed9d2f1b2e6a7207a0aa82d82da4ea372b2a4fad5526" + }, + "Std.Tactic.BVDecide.LRAT": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT.olean", + "sha256": "d355212d6f59c522d94e3c3dd34e3a02d74584f21270d3c75fd0f7b0fc1e6b23" + }, + "Std.Tactic.BVDecide.LRAT.Actions": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Actions.olean", + "sha256": "0077323c22e78b14dd46684d812da596c363a8f835ab47d9b7b429edcaf77c6f" + }, + "Std.Tactic.BVDecide.LRAT.Checker": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Checker.olean", + "sha256": "24cd2c42a4f2f34ecb83b2214194c9c808c7cc2ae49763f785d66911fb791e64" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Actions": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Actions.olean", + "sha256": "6a8d16b5f258b9da457a8dae2729cf9cc8184ae3770c62c7767b60610d12cbf2" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Assignment": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Assignment.olean", + "sha256": "1dc4cf78bf8dd9093f22e8fb31fc2585a676096e1f92d8a169853e8c32e27868" + }, + "Std.Tactic.BVDecide.LRAT.Internal.CNF": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/CNF.olean", + "sha256": "5b09536fadc7ad28c0597d86a2926cc69397fbf93011a53ec07f3bc5d8144527" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Clause": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Clause.olean", + "sha256": "c0ee4492b32ab35324ba3aa234288a517bbfd1a057b55a12b5587579dc8de5e4" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Convert": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Convert.olean", + "sha256": "644f9516699727499c6bbf434dc411c7e32be39727c27df9fcf4ac4bc7885dfd" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Entails": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Entails.olean", + "sha256": "555bd01a87e35f742a6784327cb0e15caa4b4589fdcb23b7d156612c8359aa60" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula.olean", + "sha256": "e402782d59c498b9098addaf51b65c2a1f76015a3626d11ab150c7f8e4525e3c" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Class": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Class.olean", + "sha256": "61faf33007eb81ff1ba8c12c4829d6b8353b52580d1ae32216c5acce24117930" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Implementation.olean", + "sha256": "d8d956c48977e92718e15f51f3ed0e37b2523e84129f48c93d738a5ecc73e598" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Instance.olean", + "sha256": "02dc2826a248aba00b4ff538bf73d1e84a1d26cb6bd86878e9aeaf96911578ea" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/Lemmas.olean", + "sha256": "326b363db75185b4e385f6d5ed25e3bc52249695cd47e96f7291b2befc17d99d" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddResult.olean", + "sha256": "c8ae044e3f0cbfbdd16a5c8776c5bb505b8edecd7caa7227ac3e268f8e5a813b" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RatAddSound.olean", + "sha256": "f4639e7f4ce1257677cb3ef954622a378c51facaa49d1c2033d655a0429854ee" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddResult.olean", + "sha256": "3db7edc84442cd86d9688f0259a59868e76ed0759f2d86dd35da5b8e928fecb5" + }, + "Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/Formula/RupAddSound.olean", + "sha256": "7584cffd13ae359e9c7ef8edaea45c6d0233fbdcee5d80ee57aa9ac5284af5ce" + }, + "Std.Tactic.BVDecide.LRAT.Internal.LRATChecker": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATChecker.olean", + "sha256": "adad26830176d3fbb2cbd64c83197f5083e196b2a2651ee8d7194512724770da" + }, + "Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/LRATCheckerSound.olean", + "sha256": "b21dfacd5f2e5488e49885bfcf7de9deeb429a3c12a9a5d595f9f118372e8f90" + }, + "Std.Tactic.BVDecide.LRAT.Internal.PosFin": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Internal/PosFin.olean", + "sha256": "c9064ca9acae028a144600c48c49583991419d743274fc91d3bc6033e5f647a5" + }, + "Std.Tactic.BVDecide.LRAT.Parser": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/LRAT/Parser.olean", + "sha256": "99c91ddf2e3209427989057505c6db8ae009b0b66473add1123091e82eae22d5" + }, + "Std.Tactic.BVDecide.Normalize": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize.olean", + "sha256": "5a32966bb5d1d044ebbfa16701971c19613410077471fd78907932d23ac9d896" + }, + "Std.Tactic.BVDecide.Normalize.BitVec": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/BitVec.olean", + "sha256": "9a5419dace60a2336218c9900ccc2ba5b1740ee3ad3395204c1db96e2ee1265a" + }, + "Std.Tactic.BVDecide.Normalize.Bool": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Bool.olean", + "sha256": "e4a7ad5bb1aa46632d4f53c2e534df650adbab5d2299ab05f9357bf814568c02" + }, + "Std.Tactic.BVDecide.Normalize.Canonicalize": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Canonicalize.olean", + "sha256": "42efde7852aa32bfb49a2096a017f1acc3de2be1843f9a766fc33a2e8dba6ec9" + }, + "Std.Tactic.BVDecide.Normalize.Equal": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Equal.olean", + "sha256": "b811a7a95c0f5e441dfc6b4cefb0eec03e237442d2c57224fa4cf498436be742" + }, + "Std.Tactic.BVDecide.Normalize.Prop": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Normalize/Prop.olean", + "sha256": "299264cac5f784ffcb12d7ec211033cf7913c4470e7ff363ade0cbbd2f18ea9a" + }, + "Std.Tactic.BVDecide.Reflect": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Reflect.olean", + "sha256": "6fa2f9828a59c1674437bee299f112a673ce7a30add77784b2bb610b6fdb50c6" + }, + "Std.Tactic.BVDecide.Syntax": { + "relative_path": "lib/lean/Std/Tactic/BVDecide/Syntax.olean", + "sha256": "0359dc3655c79f41a47af4d3c87485f738b79ac032d59738bbf48e16027416ba" + }, + "Std.Time": { + "relative_path": "lib/lean/Std/Time.olean", + "sha256": "0789687baa3558734be38cc4d152d748e9c6d2edf399507a1976246ce1db15d9" + }, + "Std.Time.Date": { + "relative_path": "lib/lean/Std/Time/Date.olean", + "sha256": "cb70aed3ccf7127c906dcab116c95c522aecb3987140814941c84eae42bf3f2a" + }, + "Std.Time.Date.Basic": { + "relative_path": "lib/lean/Std/Time/Date/Basic.olean", + "sha256": "f307e1a552373d28301792b5ca8bd0110b8e9d93eb81575689fbe3efd52b7ed8" + }, + "Std.Time.Date.PlainDate": { + "relative_path": "lib/lean/Std/Time/Date/PlainDate.olean", + "sha256": "9e9df12ccb5c285114cfdcf4039a2a021614747c9c45ccb6995722d248ddf3bb" + }, + "Std.Time.Date.Unit.Basic": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Basic.olean", + "sha256": "a073a7513d6b1fd55d88c56f341a3db71a933ee0563334e869db0e51618648f7" + }, + "Std.Time.Date.Unit.Day": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Day.olean", + "sha256": "5ebf7bb099376860bc2f18e7301dc33b2fba23a8de092dfa4ccc540a607edb1f" + }, + "Std.Time.Date.Unit.Month": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Month.olean", + "sha256": "795840aeee04727bd136c09d6f7c57c5eab32967bc5baa642caa071700d6f5ba" + }, + "Std.Time.Date.Unit.Week": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Week.olean", + "sha256": "1af7b14f7241b1157f7ede0be10b1ce8f84d59629fe9256ef2853f93f9920d10" + }, + "Std.Time.Date.Unit.Weekday": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Weekday.olean", + "sha256": "58a27e1054c0f7083540030928455a2f7f89568fd4df27904a992312e540431a" + }, + "Std.Time.Date.Unit.Year": { + "relative_path": "lib/lean/Std/Time/Date/Unit/Year.olean", + "sha256": "1429b88657ba6078d953466050ae379a2c0ad32f908e64d3791b3f91271ab506" + }, + "Std.Time.Date.ValidDate": { + "relative_path": "lib/lean/Std/Time/Date/ValidDate.olean", + "sha256": "ace3749ecca5141ab1d66312455cbc165abe4a5e2a92e99181bdcab5a45dcaf8" + }, + "Std.Time.DateTime": { + "relative_path": "lib/lean/Std/Time/DateTime.olean", + "sha256": "bace36aa9c50b519ee6e46e6489fdfe349e77b3f7f00e952b8ddc54361639811" + }, + "Std.Time.DateTime.PlainDateTime": { + "relative_path": "lib/lean/Std/Time/DateTime/PlainDateTime.olean", + "sha256": "1296dc0c67ac54dbc5d0b1977fcfff082655daaea079ba088c070cdc4890924c" + }, + "Std.Time.DateTime.Timestamp": { + "relative_path": "lib/lean/Std/Time/DateTime/Timestamp.olean", + "sha256": "b4cd23a2f4ea4c96f2df2b83cfc655d0e19bef0238f6c044bf37b417faeb8756" + }, + "Std.Time.Duration": { + "relative_path": "lib/lean/Std/Time/Duration.olean", + "sha256": "768a81cc06f2a7b70728d660889a4e243f0fcfcf9270cdf735c7f95a26775a81" + }, + "Std.Time.Format": { + "relative_path": "lib/lean/Std/Time/Format.olean", + "sha256": "8d0928fbefb93f6de1f46e7e622f86beadb3e27115a29880eb0745b6fd74b7d4" + }, + "Std.Time.Format.Basic": { + "relative_path": "lib/lean/Std/Time/Format/Basic.olean", + "sha256": "23d409ed591814fd515cfb89781c282bf1990635241a8dac0fe4aa40668ce135" + }, + "Std.Time.Internal": { + "relative_path": "lib/lean/Std/Time/Internal.olean", + "sha256": "aecafe702fdd9d7c770b6b7d4d1843616ed03470014b13ea1ffc0d376c8091f0" + }, + "Std.Time.Internal.Bounded": { + "relative_path": "lib/lean/Std/Time/Internal/Bounded.olean", + "sha256": "49de757e44969f7b58b61b2218ba797db7d82682f64e272a249ffa13cec52d06" + }, + "Std.Time.Internal.UnitVal": { + "relative_path": "lib/lean/Std/Time/Internal/UnitVal.olean", + "sha256": "2293196364e88707f8cb1d82e99a18f155630a82a60f1ea6399f0144fdb6ef3f" + }, + "Std.Time.Notation": { + "relative_path": "lib/lean/Std/Time/Notation.olean", + "sha256": "9e9cd56d4bb18752d074d9a5545677bf880510f07038ad29595c0d88754b21c0" + }, + "Std.Time.Notation.Spec": { + "relative_path": "lib/lean/Std/Time/Notation/Spec.olean", + "sha256": "a08aada50626422dffd9168eccc354a0dda7769fc33d943c48d5c6dbeba380dd" + }, + "Std.Time.Time": { + "relative_path": "lib/lean/Std/Time/Time.olean", + "sha256": "aaa5e2da3807c23c60e80153e6a683af0835a58d89805dfb52cf9cfcdd09599b" + }, + "Std.Time.Time.Basic": { + "relative_path": "lib/lean/Std/Time/Time/Basic.olean", + "sha256": "08e7ff82d05c4f4aa49fc9b0702a1d499f31334df58a4dd693c92cf1860f50e8" + }, + "Std.Time.Time.HourMarker": { + "relative_path": "lib/lean/Std/Time/Time/HourMarker.olean", + "sha256": "be5bbcafbc86d200ae38d3681fa62eb89c5f92e54e658ce926f535a4ea5b7821" + }, + "Std.Time.Time.PlainTime": { + "relative_path": "lib/lean/Std/Time/Time/PlainTime.olean", + "sha256": "c341b0c38877ca56f7b8b758947b2e4cbe2cc5818286d78c4cb7d7f08fe60580" + }, + "Std.Time.Time.Unit.Basic": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Basic.olean", + "sha256": "d9802ce1313c896333ee3ad31889057c81f13bd40510da853d711018eb82deee" + }, + "Std.Time.Time.Unit.Hour": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Hour.olean", + "sha256": "cd26a34fd6964178efcfa29c86f9f240bb61dd601ec6e8a4daaa4fa1aeae1085" + }, + "Std.Time.Time.Unit.Millisecond": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Millisecond.olean", + "sha256": "f276ecae1131a214858236a4e6e3f495fc7e01d551d3b0bfa98c18301dea92f2" + }, + "Std.Time.Time.Unit.Minute": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Minute.olean", + "sha256": "7c9dc59498474221677908f899f8f8b98ccc4bcb9ced0a76b4b73608e03d1cb6" + }, + "Std.Time.Time.Unit.Nanosecond": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Nanosecond.olean", + "sha256": "6bc08672ed7d3e38d0343ce320ae09b2022fe6dab7e13c589dd11a12f6761147" + }, + "Std.Time.Time.Unit.Second": { + "relative_path": "lib/lean/Std/Time/Time/Unit/Second.olean", + "sha256": "19a8c2259f0d51723c508d313c5d2da2896a5af464e9d6c809e047a772d49969" + }, + "Std.Time.Zoned": { + "relative_path": "lib/lean/Std/Time/Zoned.olean", + "sha256": "84ada81b95c5f170f68d7d2ec234bd3d007ad45d18364e531e5307f2c4d32617" + }, + "Std.Time.Zoned.Database": { + "relative_path": "lib/lean/Std/Time/Zoned/Database.olean", + "sha256": "5a324870d1bb5c102a79717c53840bb87ebbe4c7afb03499a31fb7aa51e04e8f" + }, + "Std.Time.Zoned.Database.Basic": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/Basic.olean", + "sha256": "76d13490a9d782e3c2616634c1d450f81d7978f836d5b7e6969361297a0287c9" + }, + "Std.Time.Zoned.Database.TZdb": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/TZdb.olean", + "sha256": "3345c6282c8805f291bfe6a6c219d4f8d21a2ab8aff2ad46e169aa33c073f777" + }, + "Std.Time.Zoned.Database.TzIf": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/TzIf.olean", + "sha256": "8fe12d507111f7ec04b7d1594959d190604da5bb3a0d944101472cedc2f4da02" + }, + "Std.Time.Zoned.Database.Windows": { + "relative_path": "lib/lean/Std/Time/Zoned/Database/Windows.olean", + "sha256": "50d1a55ee0a71ddf05198a448f019c2bab95dab5d0e930157c220b8d349cbbdd" + }, + "Std.Time.Zoned.DateTime": { + "relative_path": "lib/lean/Std/Time/Zoned/DateTime.olean", + "sha256": "d313bdaf5fdefdc120eb57b5736d495d60ff33febf26db330e1fd99a7a2c396c" + }, + "Std.Time.Zoned.Offset": { + "relative_path": "lib/lean/Std/Time/Zoned/Offset.olean", + "sha256": "41d7f3f24b83359a4da791ff9d6e390bc19a09d0335086be6ac37b809ec75e5b" + }, + "Std.Time.Zoned.TimeZone": { + "relative_path": "lib/lean/Std/Time/Zoned/TimeZone.olean", + "sha256": "406fac44af49c5324d4857665a38f696fe47a0c15fbca5b458279e1c4a32c39e" + }, + "Std.Time.Zoned.ZoneRules": { + "relative_path": "lib/lean/Std/Time/Zoned/ZoneRules.olean", + "sha256": "86b9ebb4ce064c7f5c68fe3933a99d30e53d74c0a967669b7f23baffe77a4f1a" + }, + "Std.Time.Zoned.ZonedDateTime": { + "relative_path": "lib/lean/Std/Time/Zoned/ZonedDateTime.olean", + "sha256": "22285b4d4b6851745f3ba5b2fb79d739eb3000deebcc2ccdfbedec637ee53cd8" + } +} diff --git a/formal/sonification/mat009/lean/negative.py b/formal/sonification/mat009/lean/negative.py index bebe4a2..5295022 100644 --- a/formal/sonification/mat009/lean/negative.py +++ b/formal/sonification/mat009/lean/negative.py @@ -14,7 +14,7 @@ HERE = Path(__file__).resolve().parent ROOT = HERE.parents[3] -BASELINE = "a09aab6572fb9c3875d5f2940bdb17ec55c358d5" +BASELINE = "c562377308ebbb4694685076af12e79eefe0a479" MODULES = ("SplitModel", "DiagnosticFirstOwner", "TypedConsumer", "ExactTypes", "LeanAudit") diff --git a/formal/sonification/mat009/lean/verify.py b/formal/sonification/mat009/lean/verify.py index cec41b3..5b52538 100644 --- a/formal/sonification/mat009/lean/verify.py +++ b/formal/sonification/mat009/lean/verify.py @@ -16,9 +16,9 @@ HERE = Path(__file__).resolve().parent ROOT = HERE.parents[3] -DEFAULT_ATTEMPT = HERE / "attempts/002" -BASELINE = "a09aab6572fb9c3875d5f2940bdb17ec55c358d5" -MANIFEST_SHA256 = "c068cb09fa08737a25bf49c17fa7cbca1e31dbbaa5ab388532b5529e1e41c817" +DEFAULT_ATTEMPT = HERE / "attempts/003" +BASELINE = "c562377308ebbb4694685076af12e79eefe0a479" +MANIFEST_SHA256 = "575f9996a160db4ff01b69a155f2210046ce7a40b4d2ffdd78ca7c13afeb73be" MODULES = ( "SplitModel", "DiagnosticFirstOwner", "TypedConsumer", "ExactTypes", "LeanAudit", From b07942c77bebb15c99d8a70f52397d4077694ea0 Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 12:31:15 +1030 Subject: [PATCH 19/22] formal(mat009): bind retained bypass and seven repaired negative controls --- .../EVIDENCE_MANIFEST.json | 66 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 17 + .../mutant-source.lean.txt | 78 + .../result.json | 37 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1467 ++++++++++++++++ .../mutant-source.lean.txt | 382 +++++ .../compiler_suffix_false_axiom/result.json | 76 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 29 + .../mutant-source.lean.txt | 379 +++++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 42 + .../mutant-source.lean.txt | 379 +++++ .../result.json | 24 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1493 ++++++++++++++++ .../mutant-source.lean.txt | 381 +++++ .../prohibited_project_axiom/result.json | 76 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 1 + .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1500 +++++++++++++++++ .../prohibited_sorry/mutant-source.lean.txt | 381 +++++ .../prohibited_sorry/result.json | 76 + .../005-negative-controls/result.json | 53 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 68 + .../mutant-source.lean.txt | 369 ++++ .../weaken_final_leakage_theorem/result.json | 50 + .../sonification/mat009/lean/verify_repair.py | 119 ++ ...sonification_formal_mat009_suffix_axiom.py | 30 + 62 files changed, 7810 insertions(+) create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/EVIDENCE_MANIFEST.json create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/result.json create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/result.json create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/result.json create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/result.json create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/result.json create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/result.json create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/result.json create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/mutant-source.lean.txt create mode 100644 formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/result.json create mode 100644 formal/sonification/mat009/lean/verify_repair.py create mode 100644 tests/test_sonification_formal_mat009_suffix_axiom.py diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/EVIDENCE_MANIFEST.json b/formal/sonification/mat009/lean/recovery/005-negative-controls/EVIDENCE_MANIFEST.json new file mode 100644 index 0000000..2d9e805 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/EVIDENCE_MANIFEST.json @@ -0,0 +1,66 @@ +{ + "files_sha256": { + "change_diagnostic_first_owner_update/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "change_diagnostic_first_owner_update/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "change_diagnostic_first_owner_update/mutant-source.lean.txt": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "change_diagnostic_first_owner_update/result.json": "79ecb89fe9b3ecd864a9157bd3f4829922d5d4e7e7c53a445215d912a6fb9a50", + "compiler_suffix_false_axiom/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "compiler_suffix_false_axiom/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "compiler_suffix_false_axiom/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "compiler_suffix_false_axiom/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "compiler_suffix_false_axiom/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "compiler_suffix_false_axiom/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "compiler_suffix_false_axiom/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "compiler_suffix_false_axiom/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "compiler_suffix_false_axiom/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "compiler_suffix_false_axiom/build-04-LeanAudit.stdout": "b9cf7b27170adfe76737ef26d2e989989103b66cb6f8b00c78434b41457872a2", + "compiler_suffix_false_axiom/mutant-source.lean.txt": "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71", + "compiler_suffix_false_axiom/result.json": "6c881312b71015c51fbce1960a8e185a9ea411cc597d68c157a9b2bd23188a4f", + "drop_cross_conflict_stickiness/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "drop_cross_conflict_stickiness/build-00-SplitModel.stdout": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "drop_cross_conflict_stickiness/mutant-source.lean.txt": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "drop_cross_conflict_stickiness/result.json": "0c2c8d0ee06e736c332203764d44fbd1b521a3d1a03eefde429354b4c21490c6", + "drop_historical_campaign_membership/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "drop_historical_campaign_membership/build-00-SplitModel.stdout": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "drop_historical_campaign_membership/mutant-source.lean.txt": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "drop_historical_campaign_membership/result.json": "8b8a842c9fe4853c5e97fe6042aa347afb979c066b2802382bdc9a5048ac0b3b", + "prohibited_project_axiom/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_project_axiom/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_project_axiom/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_project_axiom/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "prohibited_project_axiom/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_project_axiom/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_project_axiom/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_project_axiom/build-04-LeanAudit.stdout": "8d5f060fba7ffe615d8d0a9cd230e70a090cfad3299606322e03b2f35b7cee13", + "prohibited_project_axiom/mutant-source.lean.txt": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "prohibited_project_axiom/result.json": "a61cdf682a9040a4c5169412b6e7cb29eac4be2f771b0b0579375fe85f65293e", + "prohibited_sorry/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_sorry/build-00-SplitModel.stdout": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "prohibited_sorry/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_sorry/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_sorry/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_sorry/build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "prohibited_sorry/build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_sorry/build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_sorry/build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "prohibited_sorry/build-04-LeanAudit.stdout": "4a95308c27fc61eaeea5f4bf90d867f213ecd1d227185c3845104ac72e7ebc76", + "prohibited_sorry/mutant-source.lean.txt": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "prohibited_sorry/result.json": "465cfd001ea960a07c62b622e6f7cd74ac8e489c4d7be1f250ddf18b9ab7f29f", + "result.json": "72c1fe6213febce558751f79abecc0768658c5b751b4f00f0ee556851043576a", + "weaken_final_leakage_theorem/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "weaken_final_leakage_theorem/build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "weaken_final_leakage_theorem/build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "weaken_final_leakage_theorem/build-02-TypedConsumer.stdout": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "weaken_final_leakage_theorem/mutant-source.lean.txt": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "weaken_final_leakage_theorem/result.json": "6763c475b8ea49c2244fb61d2024d3e480922b023bce125520c8db82ff055b7f" + }, + "proof_input_commit": "c562377308ebbb4694685076af12e79eefe0a479", + "runner_commit": "e1091de3bce9502ad333c530c1d7b12eb143f6da", + "schema": "mat009-repaired-negative-controls/v1" +} diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..338f088 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/build-01-DiagnosticFirstOwner.stdout @@ -0,0 +1,17 @@ +DiagnosticFirstOwner.lean:23:13: warning: unused variable `first` +note: this linter can be disabled with `set_option linter.unusedVariables false` +DiagnosticFirstOwner.lean:35:68: error: unsolved goals +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:55:2: error: unsolved goals +case pos +registry : Registry +identity : String +candidate first : Owner +h : registry identity = some first +⊢ candidate = first +DiagnosticFirstOwner.lean:75:38: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/mutant-source.lean.txt b/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/mutant-source.lean.txt new file mode 100644 index 0000000..7dd6c18 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/mutant-source.lean.txt @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some candidate + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/result.json b/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/result.json new file mode 100644 index 0000000..4a6fc0c --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/change_diagnostic_first_owner_update/result.json @@ -0,0 +1,37 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-dqncars1/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-change_diagnostic_first_owner_update-dqncars1/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "fbe0315c2d7a3bd1dfd7c80f221a1966bab1f771a443d3aa7322a3577f9719e6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "DiagnosticFirstOwner", + "mutant_sha256": "1b9a3cb9293f8f56506676d481053f28c46c79896e7be2f80774a7740339a146", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner", + "target_module": "DiagnosticFirstOwner" +} diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-03-ExactTypes.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-03-ExactTypes.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-04-LeanAudit.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-04-LeanAudit.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-04-LeanAudit.stdout new file mode 100644 index 0000000..ad27e18 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/build-04-LeanAudit.stdout @@ -0,0 +1,1467 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +LeanAudit.lean:12:0: error: project axiom declaration MAT009.auditor_false_cstage1 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/mutant-source.lean.txt b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/mutant-source.lean.txt new file mode 100644 index 0000000..de82e6b --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/mutant-source.lean.txt @@ -0,0 +1,382 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom auditor_false_cstage1 : False +theorem auditor_false_proof_cstage1 : False := auditor_false_cstage1 + +end MAT009 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/result.json b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/result.json new file mode 100644 index 0000000..4ee4e05 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/compiler_suffix_false_axiom/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-compiler_suffix_false_axiom-sjq_3eij/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-compiler_suffix_false_axiom-sjq_3eij/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-compiler_suffix_false_axiom-sjq_3eij/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-compiler_suffix_false_axiom-sjq_3eij/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-compiler_suffix_false_axiom-sjq_3eij/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "b9cf7b27170adfe76737ef26d2e989989103b66cb6f8b00c78434b41457872a2", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "project axiom declaration MAT009.auditor_false_cstage1", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71", + "mutation": "compiler_suffix_false_axiom", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/build-00-SplitModel.stdout new file mode 100644 index 0000000..7afbe9e --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/build-00-SplitModel.stdout @@ -0,0 +1,29 @@ +SplitModel.lean:157:2: error: tactic 'rfl' failed, the left-hand side + (step s row).crossed +is not definitionally equal to the right-hand side + s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +s : State +row : Row +⊢ (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +SplitModel.lean:173:4: error: type mismatch + Or.inl h +has type + s.crossed ∨ ?m.4965 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:260:33: error: application type mismatch + ih (step s row) (Or.inl h) +argument + Or.inl h +has type + s.crossed ∨ ?m.5382 : Prop +but is expected to have type + (step s row).crossed : Prop +SplitModel.lean:285:36: error: application type mismatch + scan_crossed_sticky (step (scan s before) row) after (Or.inr h) +argument + Or.inr h +has type + ?m.5421 ∨ ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role : Prop +but is expected to have type + (step (scan s before) row).crossed : Prop diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/mutant-source.lean.txt b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/mutant-source.lean.txt new file mode 100644 index 0000000..bf51182 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/result.json b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/result.json new file mode 100644 index 0000000..d81d2ce --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_cross_conflict_stickiness/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_cross_conflict_stickiness-8ilsmbh7/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "deccbc1b2ad894ddda5e402e572b633b6905679296db9b634bedb5079b7cd9ae", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "application type mismatch", + "expected_failure_module": "SplitModel", + "mutant_sha256": "5be10a071b0334819e1254d756de487f062d07e57df833421947aa4ce32e2c88", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/build-00-SplitModel.stdout new file mode 100644 index 0000000..4bac996 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/build-00-SplitModel.stdout @@ -0,0 +1,42 @@ +SplitModel.lean:79:23: error: application type mismatch + And.intro (Or.inl htrain) +argument + Or.inl htrain +has type + s.campaigns Role.train key ∨ ?m.3876 : Prop +but is expected to have type + (step s row).campaigns Role.train key : Prop +SplitModel.lean:147:4: error: tactic 'rfl' failed, the left-hand side + (step s row).campaigns role key +is not definitionally equal to the right-hand side + s.campaigns role key ∨ role = row.role ∧ key = row.campaign +case refine_3 +s : State +row : Row +role : Role +key : String +⊢ (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign +SplitModel.lean:169:4: error: type mismatch + Or.inl h +has type + s.campaigns role campaign ∨ ?m.4953 : Prop +but is expected to have type + (step s row).campaigns role campaign : Prop +SplitModel.lean:222:21: error: unsolved goals +case cons +role : Role +key : String +row : Row +rest : List Row +ih : + ∀ (s : State), + (scan s rest).campaigns role key ↔ s.campaigns role key ∨ ∃ row, row ∈ rest ∧ row.role = role ∧ row.campaign = key +s : State +hhead : + (∃ r, r ∈ row :: rest ∧ r.role = role ∧ r.campaign = key) ↔ + row.role = role ∧ row.campaign = key ∨ ∃ r, r ∈ rest ∧ r.role = role ∧ r.campaign = key +⊢ (role = row.role ∧ key = row.campaign ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign) ↔ + role = row.role ∧ key = row.campaign ∨ + s.campaigns role key ∨ ∃ row, row ∈ rest ∧ role = row.role ∧ key = row.campaign +SplitModel.lean:368:35: error: unsolved goals +⊢ False diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/mutant-source.lean.txt b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/mutant-source.lean.txt new file mode 100644 index 0000000..abf1e5e --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/mutant-source.lean.txt @@ -0,0 +1,379 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/result.json b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/result.json new file mode 100644 index 0000000..fb58aa3 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/drop_historical_campaign_membership/result.json @@ -0,0 +1,24 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-drop_historical_campaign_membership-0lz5ey85/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "0820f4f224e05616b307dc467503d76a038d19b0e5fca38ef72f5cf6c7ba18f6", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "unsolved goals", + "expected_failure_module": "SplitModel", + "mutant_sha256": "e2749a38389fe33c52882ec2d5dbb9a0e6de574f1a87f409bd493a89fe6192a2", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-03-ExactTypes.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-03-ExactTypes.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-04-LeanAudit.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-04-LeanAudit.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-04-LeanAudit.stdout new file mode 100644 index 0000000..1d29b81 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/build-04-LeanAudit.stdout @@ -0,0 +1,1493 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: project axiom declaration MAT009.fabricated_physical_admission diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/mutant-source.lean.txt b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/mutant-source.lean.txt new file mode 100644 index 0000000..6fb45d8 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom fabricated_physical_admission : False + +end MAT009 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/result.json b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/result.json new file mode 100644 index 0000000..11b73f8 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_project_axiom/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-l5_cxknb/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-l5_cxknb/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-l5_cxknb/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-l5_cxknb/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_project_axiom-l5_cxknb/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "8d5f060fba7ffe615d8d0a9cd230e70a090cfad3299606322e03b2f35b7cee13", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "project axiom declaration", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "3cc93725fa438ed22a81bb98786cfc5bf57416b57dea03179003e7c344cc6ee1", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-00-SplitModel.stdout new file mode 100644 index 0000000..a165e03 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-00-SplitModel.stdout @@ -0,0 +1 @@ +SplitModel.lean:379:4: warning: declaration uses 'sorry' diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-03-ExactTypes.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-03-ExactTypes.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-04-LeanAudit.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-04-LeanAudit.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-04-LeanAudit.stdout new file mode 100644 index 0000000..771a739 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/build-04-LeanAudit.stdout @@ -0,0 +1,1500 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.cleanRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_6._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_7._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._closed_8._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.cleanRows =\n [{ campaign := \"TRAIN_A\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"HELD_B\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.cleanRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.crossReason","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"String","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.crossReason = \"CAMPAIGN_CROSSES_TRAIN_HOLDOUT\"","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.crossingRows","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_2._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_3._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_4._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._closed_5._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"List MAT009.Row","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.crossingRows =\n [{ campaign := \"SAME\", lab := \"LAB_A\", role := MAT009.Role.train },\n { campaign := \"SAME\", lab := \"LAB_B\", role := MAT009.Role.holdout }]","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.crossingRows.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.familyLeakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State), MAT009.familyLeakage s = (MAT009.splitIntersection s.campaigns ∨ MAT009.splitIntersection s.labs)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.familyLeakage.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row), MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.familyLeakage_step_sticky","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.finalize","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Final","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.finalize._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.finalize._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n MAT009.finalize s = { parent := s.parent, crossed := s.crossed, leakage := MAT009.familyLeakage s }","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.finalize.eq_1","axioms":[]} +LeanAudit.lean:12:0: error: unapproved transitive axiom sorryAx in MAT009.hidden_unproved (origin SplitModel) diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/mutant-source.lean.txt b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/mutant-source.lean.txt new file mode 100644 index 0000000..287973b --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/mutant-source.lean.txt @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +def hidden_unproved : Nat := by sorry + +end MAT009 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/result.json b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/result.json new file mode 100644 index 0000000..b64053e --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/prohibited_sorry/result.json @@ -0,0 +1,76 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-4_wftjo9/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "17a2ead30f158ef7cfe7c4aded34b5dcec132b3edd441efe9d9fdff448093fca", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-4_wftjo9/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-4_wftjo9/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-4_wftjo9/ExactTypes.olean", + "ExactTypes.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-prohibited_sorry-4_wftjo9/LeanAudit.olean", + "LeanAudit.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "4a95308c27fc61eaeea5f4bf90d867f213ecd1d227185c3845104ac72e7ebc76", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "sorryAx", + "expected_failure_module": "LeanAudit", + "mutant_sha256": "adfc58d6db8b119e29bfe2dafcae69cd21b59988853464716084fa9eafbe9fd5", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/result.json b/formal/sonification/mat009/lean/recovery/005-negative-controls/result.json new file mode 100644 index 0000000..132a89c --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/result.json @@ -0,0 +1,53 @@ +{ + "REFINEMENT_PROVED": "OPEN", + "cases": [ + { + "detected": true, + "expected_failure_module": "SplitModel", + "mutation": "drop_cross_conflict_stickiness", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "SplitModel", + "mutation": "drop_historical_campaign_membership", + "observed_failure_module": "SplitModel" + }, + { + "detected": true, + "expected_failure_module": "TypedConsumer", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer" + }, + { + "detected": true, + "expected_failure_module": "DiagnosticFirstOwner", + "mutation": "change_diagnostic_first_owner_update", + "observed_failure_module": "DiagnosticFirstOwner" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "prohibited_project_axiom", + "observed_failure_module": "LeanAudit" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "compiler_suffix_false_axiom", + "observed_failure_module": "LeanAudit" + }, + { + "detected": true, + "expected_failure_module": "LeanAudit", + "mutation": "prohibited_sorry", + "observed_failure_module": "LeanAudit" + } + ], + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "negative_runner_commit": "e1091de3bce9502ad333c530c1d7b12eb143f6da", + "negative_runner_sha256": "9ee63fda2cd0a6e045c85a99ce28e20ea6f2d6d800e38ed5088ce9432acfeb48", + "proof_input_commit": "c562377308ebbb4694685076af12e79eefe0a479", + "scope": "negative controls for mathematical proof and trust checker only", + "status": "PASS" +} diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-00-SplitModel.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-00-SplitModel.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr b/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout b/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..85516a3 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/build-02-TypedConsumer.stdout @@ -0,0 +1,68 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff : True +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +TypedConsumer.lean:43:9: error: function expected at + M009_R6_final_leakage_iff +term has type + True +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' does not depend on any axioms +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, sorryAx, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/mutant-source.lean.txt b/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/mutant-source.lean.txt new file mode 100644 index 0000000..bd8b105 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/mutant-source.lean.txt @@ -0,0 +1,369 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff : True := by trivial + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +end MAT009 diff --git a/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/result.json b/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/result.json new file mode 100644 index 0000000..88f0529 --- /dev/null +++ b/formal/sonification/mat009/lean/recovery/005-negative-controls/weaken_final_leakage_theorem/result.json @@ -0,0 +1,50 @@ +{ + "commands": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-e9087yu5/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-e9087yu5/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "timed_out": false + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/tmp/mat009-weaken_final_leakage_theorem-e9087yu5/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "c015896a5cb42899f129d84e30b6b35b66b1e22834409e8375c107ca3b9a4743", + "timed_out": false + } + ], + "detected": true, + "expected_diagnostic_text": "M009_R6_final_leakage_iff", + "expected_failure_module": "TypedConsumer", + "mutant_sha256": "61a2c2f1dc9b59050a60927232322079492bfb9dfffd0ac788cfc3b95382cff1", + "mutation": "weaken_final_leakage_theorem", + "observed_failure_module": "TypedConsumer", + "target_module": "SplitModel" +} diff --git a/formal/sonification/mat009/lean/verify_repair.py b/formal/sonification/mat009/lean/verify_repair.py new file mode 100644 index 0000000..c5b5e91 --- /dev/null +++ b/formal/sonification/mat009/lean/verify_repair.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python3 +"""Bind the retained suffix-axiom bypass and its repaired negative controls.""" + +from __future__ import annotations + +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ORIGINAL = HERE / "recovery/001-original-bypass" +CORRECTED = HERE / "recovery/005-negative-controls" +ORIGINAL_MANIFEST_SHA256 = "783d4d69de3fdfa810899143a3a2bf03f13e3bd3aa3eda935356763e404d8350" +CORRECTED_MANIFEST_SHA256 = "1e1efa7eb0d4aedc1e43f096cc2610a6bd2d733a69a1e0f35d91e78a86eae191" +MUTANT_SHA256 = "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71" +OLD_SCANNER_SHA256 = "7aeabffbd65357e4ea41d773950bc7b52c892c5347b259f51d6a3831296aced8" +NEW_RUNNER_SHA256 = "9ee63fda2cd0a6e045c85a99ce28e20ea6f2d6d800e38ed5088ce9432acfeb48" +PROOF_COMMIT = "c562377308ebbb4694685076af12e79eefe0a479" +RUNNER_COMMIT = "e1091de3bce9502ad333c530c1d7b12eb143f6da" +CASES = { + "drop_cross_conflict_stickiness", + "drop_historical_campaign_membership", + "weaken_final_leakage_theorem", + "change_diagnostic_first_owner_update", + "prohibited_project_axiom", + "prohibited_sorry", + "compiler_suffix_false_axiom", +} + + +def sha(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def require(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def manifest_files(base: Path, name: str, digest: str) -> dict[str, str]: + require(base.is_dir() and not base.is_symlink(), f"missing evidence directory: {base}") + path = base / name + require(path.is_file() and not path.is_symlink() and sha(path.read_bytes()) == digest, + f"changed evidence manifest: {base}") + files = json.loads(path.read_text())["files_sha256"] + observed = {str(p.relative_to(base)) for p in base.rglob("*") if p.is_file()} + require(observed == set(files) | {name}, f"evidence file inventory changed: {base}") + for relative, expected in files.items(): + member = Path(relative) + require(not member.is_absolute() and ".." not in member.parts, + f"invalid evidence path: {relative}") + source = base / member + require(source.is_file() and not source.is_symlink() and + sha(source.read_bytes()) == expected, + f"altered evidence file: {relative}") + return files + + +def verify(original: Path = ORIGINAL, corrected: Path = CORRECTED) -> dict: + manifest_files(original, "manifest.json", ORIGINAL_MANIFEST_SHA256) + result = json.loads((original / "result.json").read_text()) + require(result["bypass_reproduced"] is True and + result["retained_mutant_sha256"] == MUTANT_SHA256 and + result["original_scanner_sha256"] == OLD_SCANNER_SHA256 and + sha((original / "work/LeanAudit.lean").read_bytes()) == OLD_SCANNER_SHA256 and + len(result["jobs"]) == 5 and + all(job["exit_code"] == 0 for job in result["jobs"]), + "original vulnerable gate did not accept the retained mutant") + false_rows = result["false_declarations"] + require({row["declaration"] for row in false_rows} == { + "MAT009.auditor_false_cstage1", "MAT009.auditor_false_proof_cstage1" + } and all(row["kind"] == "compiler_auxiliary" and row["type"] == "False" + for row in false_rows), "original False declarations changed") + + manifest_files(corrected, "EVIDENCE_MANIFEST.json", CORRECTED_MANIFEST_SHA256) + report = json.loads((corrected / "result.json").read_text()) + require(report["status"] == "PASS" and + report["proof_input_commit"] == PROOF_COMMIT and + report["negative_runner_commit"] == RUNNER_COMMIT and + report["negative_runner_sha256"] == NEW_RUNNER_SHA256 and + sha((HERE / "negative.py").read_bytes()) == NEW_RUNNER_SHA256 and + report["REFINEMENT_PROVED"] == "OPEN" and + {case["mutation"] for case in report["cases"]} == CASES and + all(case["detected"] for case in report["cases"]), + "repaired negative control set changed") + for case in report["cases"]: + name = case["mutation"] + folder = corrected / name + detail = json.loads((folder / "result.json").read_text()) + require(detail["detected"] is True and detail["mutation"] == name and + detail["observed_failure_module"] == + detail["expected_failure_module"] == case["observed_failure_module"] and + sha((folder / "mutant-source.lean.txt").read_bytes()) == + detail["mutant_sha256"], f"negative control changed: {name}") + for index, job in enumerate(detail["commands"]): + module = job["argv"][-1].removesuffix(".lean") + label = f"build-{index:02d}-{module}" + require(job["timed_out"] is False and + (job["exit_code"] == 0 if index + 1 < len(detail["commands"]) + else job["exit_code"] != 0), + f"negative control exit changed: {name}/{label}") + for stream in ("stdout", "stderr"): + require(sha((folder / f"{label}.{stream}").read_bytes()) == + job[f"{stream}_sha256"], + f"negative control log changed: {name}/{label}") + suffix = json.loads((corrected / "compiler_suffix_false_axiom/result.json").read_text()) + log = (corrected / "compiler_suffix_false_axiom/build-04-LeanAudit.stdout").read_text() + require(suffix["mutant_sha256"] == MUTANT_SHA256 and + suffix["observed_failure_module"] == "LeanAudit" and + suffix["expected_diagnostic_text"] in log and + len(suffix["commands"]) == 5, + "retained suffix-axiom bypass was not rejected by repaired gate") + return {"status": "MAT009_SUFFIX_AXIOM_REPAIR_BOUND", "detected": len(CASES), + "vulnerable_gate_accepted": True, "corrected_gate_rejected": True, + "REFINEMENT_PROVED": "OPEN"} + + +if __name__ == "__main__": + print(json.dumps(verify(), sort_keys=True)) diff --git a/tests/test_sonification_formal_mat009_suffix_axiom.py b/tests/test_sonification_formal_mat009_suffix_axiom.py new file mode 100644 index 0000000..1b8185e --- /dev/null +++ b/tests/test_sonification_formal_mat009_suffix_axiom.py @@ -0,0 +1,30 @@ +"""Bind the retained compiler-suffix bypass to its repaired Lean rejection.""" + +from __future__ import annotations + +import shutil +import tempfile +import unittest +from pathlib import Path + +from formal.sonification.mat009.lean.verify_repair import CORRECTED, ORIGINAL, verify + + +class Mat009SuffixAxiomTests(unittest.TestCase): + def test_original_accepts_and_repaired_gate_rejects(self) -> None: + result = verify() + self.assertTrue(result["vulnerable_gate_accepted"]) + self.assertTrue(result["corrected_gate_rejected"]) + self.assertEqual(result["detected"], 7) + + def test_missing_rejection_log_fails_closed(self) -> None: + with tempfile.TemporaryDirectory(prefix="mat009-suffix-receipt-") as temp: + copied = Path(temp) / "corrected" + shutil.copytree(CORRECTED, copied) + (copied / "compiler_suffix_false_axiom/build-04-LeanAudit.stdout").unlink() + with self.assertRaisesRegex(ValueError, "evidence file inventory changed"): + verify(ORIGINAL, copied) + + +if __name__ == "__main__": + unittest.main() From d063ce5756d22807cecc875d0cfb1e3e4629dfdb Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 12:34:26 +1030 Subject: [PATCH 20/22] formal(mat009): retain independent repaired-gate audit --- .../audit/repair-audit-001/MANIFEST.json | 48 + .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 0 .../build-01-DiagnosticFirstOwner.stderr | 0 .../build-01-DiagnosticFirstOwner.stdout | 0 .../build-02-TypedConsumer.stderr | 0 .../build-02-TypedConsumer.stdout | 71 + .../build-03-ExactTypes.stderr | 0 .../build-03-ExactTypes.stdout | 0 .../build-04-LeanAudit.stderr | 0 .../build-04-LeanAudit.stdout | 1467 +++++++++++++++++ .../build-00-SplitModel.stderr | 0 .../build-00-SplitModel.stdout | 1 + .../compiler-axiom-leak/result.json | 19 + .../work/DiagnosticFirstOwner.lean | 78 + .../compiler-axiom-leak/work/ExactTypes.lean | 98 ++ .../compiler-axiom-leak/work/LeanAudit.lean | 89 + .../compiler-axiom-leak/work/SplitModel.lean | 381 +++++ .../work/TypedConsumer.lean | 65 + .../mat009/audit/repair-audit-001/report.json | 112 ++ .../repair-audit-001/suffix2-result.json | 75 + .../suffix2-work/DiagnosticFirstOwner.lean | 78 + .../suffix2-work/DiagnosticFirstOwner.olean | Bin 0 -> 79608 bytes .../suffix2-work/ExactTypes.lean | 98 ++ .../suffix2-work/ExactTypes.olean | Bin 0 -> 17840 bytes .../suffix2-work/LeanAudit.lean | 89 + .../suffix2-work/SplitModel.lean | 382 +++++ .../suffix2-work/SplitModel.olean | Bin 0 -> 529912 bytes .../suffix2-work/TypedConsumer.lean | 65 + .../suffix2-work/TypedConsumer.olean | Bin 0 -> 29344 bytes .../verification/lean_receipt.stderr | 0 .../verification/lean_receipt.stdout | 1 + .../verification/legacy_negative.stderr | 0 .../verification/legacy_negative.stdout | 1 + .../verification/repair_receipt.stderr | 0 .../verification/repair_receipt.stdout | 1 + .../repair-audit-001/verification/result.json | 66 + .../verification/source_binding.stderr | 0 .../verification/source_binding.stdout | 1 + .../verification/source_receipts.stderr | 0 .../verification/source_receipts.stdout | 1 + .../verification/suffix_tests.stderr | 0 .../verification/suffix_tests.stdout | 2 + 43 files changed, 3289 insertions(+) create mode 100644 formal/sonification/mat009/audit/repair-audit-001/MANIFEST.json create mode 100644 formal/sonification/mat009/audit/repair-audit-001/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/repair-audit-001/build-01-DiagnosticFirstOwner.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/build-01-DiagnosticFirstOwner.stdout create mode 100644 formal/sonification/mat009/audit/repair-audit-001/build-02-TypedConsumer.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/build-02-TypedConsumer.stdout create mode 100644 formal/sonification/mat009/audit/repair-audit-001/build-03-ExactTypes.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/build-03-ExactTypes.stdout create mode 100644 formal/sonification/mat009/audit/repair-audit-001/build-04-LeanAudit.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/build-04-LeanAudit.stdout create mode 100644 formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/build-00-SplitModel.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/build-00-SplitModel.stdout create mode 100644 formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/result.json create mode 100644 formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/DiagnosticFirstOwner.lean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/ExactTypes.lean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/LeanAudit.lean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/SplitModel.lean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/TypedConsumer.lean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/report.json create mode 100644 formal/sonification/mat009/audit/repair-audit-001/suffix2-result.json create mode 100644 formal/sonification/mat009/audit/repair-audit-001/suffix2-work/DiagnosticFirstOwner.lean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/suffix2-work/DiagnosticFirstOwner.olean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/suffix2-work/ExactTypes.lean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/suffix2-work/ExactTypes.olean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/suffix2-work/LeanAudit.lean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/suffix2-work/SplitModel.lean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/suffix2-work/SplitModel.olean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/suffix2-work/TypedConsumer.lean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/suffix2-work/TypedConsumer.olean create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/lean_receipt.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/lean_receipt.stdout create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/legacy_negative.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/legacy_negative.stdout create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/repair_receipt.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/repair_receipt.stdout create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/result.json create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/source_binding.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/source_binding.stdout create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/source_receipts.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/source_receipts.stdout create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/suffix_tests.stderr create mode 100644 formal/sonification/mat009/audit/repair-audit-001/verification/suffix_tests.stdout diff --git a/formal/sonification/mat009/audit/repair-audit-001/MANIFEST.json b/formal/sonification/mat009/audit/repair-audit-001/MANIFEST.json new file mode 100644 index 0000000..89112bb --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/MANIFEST.json @@ -0,0 +1,48 @@ +{ + "candidate_commit": "b07942c77bebb15c99d8a70f52397d4077694ea0", + "files_sha256": { + "build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-00-SplitModel.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-01-DiagnosticFirstOwner.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-02-TypedConsumer.stdout": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522", + "build-03-ExactTypes.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-03-ExactTypes.stdout": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "build-04-LeanAudit.stdout": "2f67d8b6614f70178fd99565fc5db071b3a31da9862e79d694ac5490a0b1d03e", + "compiler-axiom-leak/build-00-SplitModel.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "compiler-axiom-leak/build-00-SplitModel.stdout": "3061c0d5e518c47bf8bce304265bba661fc22d822327e45e5a87082d13902589", + "compiler-axiom-leak/result.json": "cdca15375ab8d29a0ad5222698beb9883208cfd8a36c196dc2620e2041d0940a", + "compiler-axiom-leak/work/DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "compiler-axiom-leak/work/ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "compiler-axiom-leak/work/LeanAudit.lean": "867bb9c70345c525239e6cadd6da3ec1f186f586f431855de67aadefa429882c", + "compiler-axiom-leak/work/SplitModel.lean": "ff885b6e20f693ae6d588e086ebbe659d7f3c9f604909583b7a3a5a466b1ca6e", + "compiler-axiom-leak/work/TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa", + "report.json": "203a23d0a617943dd5feddc6ff1008af973ddfe36319a387535412cdc2abb33e", + "suffix2-result.json": "11622039a565c45588a183a77ea1a7b3b7d1f35d133ab0bc3d075d471eb06e50", + "suffix2-work/DiagnosticFirstOwner.lean": "7658fa0dc0b223e69a6f145a3ac68a3f7852c597fb9c2a83a0c6870023ca4d05", + "suffix2-work/DiagnosticFirstOwner.olean": "08b4c6e3a902aab9b14d745d84e34195891f5e82b4aeb620c4c97924098c3dfe", + "suffix2-work/ExactTypes.lean": "ec371e7a14ad106fc52ecd31ca95fbc7b9aee124b7463e3f08811f215aec9fb6", + "suffix2-work/ExactTypes.olean": "b64b65124db21c2a2c958e45b5d199f08ac83b4c6ccb853c27dcf492c89b7525", + "suffix2-work/LeanAudit.lean": "867bb9c70345c525239e6cadd6da3ec1f186f586f431855de67aadefa429882c", + "suffix2-work/SplitModel.lean": "c77760060706b3a50125a2a96a437a8bf874903328681b274eb4eab49f3e0b09", + "suffix2-work/SplitModel.olean": "20a3517ab9b95c70f26b0931da0c2bb8da2204203f2b2911e998c158dc2a2572", + "suffix2-work/TypedConsumer.lean": "422315ea1451327d960ddd81b9d8fdc2189d25b02406b44c9b1786d34c70b5fa", + "suffix2-work/TypedConsumer.olean": "7dc3d93ec2f41312cca1fecb0969bb079a87ef62468260346e99a5364d8cb0fe", + "verification/lean_receipt.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "verification/lean_receipt.stdout": "c419e181e2b8bbecddb22cfbf98b41d848f22f725d939ecafcafaf326fea32d4", + "verification/legacy_negative.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "verification/legacy_negative.stdout": "8cb3c759e0dd871f132cc1524700e3908fbc88e38b5b8e39901fcbd5d9f87c21", + "verification/repair_receipt.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "verification/repair_receipt.stdout": "698f48a34790f50ec4fb32e63e4c8e1dc143f5ce7a1c8383d56d18aa2ab99204", + "verification/result.json": "6e6ac0cdfd50124edf3ef9cb9202bb93b911dd845c6eec56ff9fbfe46aa5cb33", + "verification/source_binding.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "verification/source_binding.stdout": "5a3750fcbab24ba5889a7a5439b5445d7484ac50a497ab546df22139462902b7", + "verification/source_receipts.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "verification/source_receipts.stdout": "2c408e885fa4ac144dbd6bffc148095f09f3e67db1fb054de95953589e56c816", + "verification/suffix_tests.stderr": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "verification/suffix_tests.stdout": "149e983c325e1215d8fe411fd58fb9c0fa38bc5dfa119c4a6a92d44ee61e3e10" + }, + "schema": "sonification-mat009-independent-repair-audit-files/v1" +} diff --git a/formal/sonification/mat009/audit/repair-audit-001/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/repair-audit-001/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/repair-audit-001/build-00-SplitModel.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/build-01-DiagnosticFirstOwner.stderr b/formal/sonification/mat009/audit/repair-audit-001/build-01-DiagnosticFirstOwner.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/build-01-DiagnosticFirstOwner.stdout b/formal/sonification/mat009/audit/repair-audit-001/build-01-DiagnosticFirstOwner.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/build-02-TypedConsumer.stderr b/formal/sonification/mat009/audit/repair-audit-001/build-02-TypedConsumer.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/build-02-TypedConsumer.stdout b/formal/sonification/mat009/audit/repair-audit-001/build-02-TypedConsumer.stdout new file mode 100644 index 0000000..d0fdc11 --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/build-02-TypedConsumer.stdout @@ -0,0 +1,71 @@ +MAT009.M009_R1_initial (parent : ReasonSet) (role : Role) (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬(initial parent).campaigns role campaign ∧ + ¬(initial parent).labs role lab ∧ ¬(initial parent).crossed ∧ ((initial parent).parent reason ↔ parent reason) +MAT009.M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ (key : String), key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ (role : Role) (key : String), + (step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧ + ∀ (role : Role) (key : String), (step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab +MAT009.M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role +MAT009.M009_R4_stickiness (s : State) (row : Row) (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ ((step s row).parent reason ↔ s.parent reason) +MAT009.M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns Role.train key ∧ s.campaigns Role.holdout key) ∨ + ∃ key, s.labs Role.train key ∧ s.labs Role.holdout key +MAT009.M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ s.parent leakageReason ∨ familyLeakage s +MAT009.M009_R6_cross_trigger_in_finite_scan (s : State) (before after : List Row) (row : Row) + (h : ∃ previous, (scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed +MAT009.M009_R6_arbitrary_finite_scan (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) +MAT009.M009_R6_latest_owner (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign +MAT009.M009_R6_parent_reason_survives (parent : ReasonSet) (rows : List Row) (reason : String) : + parent reason → (finalize (scan (initial parent) rows)).hasReason reason +MAT009.M009_R6_final_leakage_iff (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.campaign = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.campaign = key) ∨ + ∃ key, + (∃ row, row ∈ rows ∧ row.role = Role.train ∧ row.lab = key) ∧ + ∃ row, row ∈ rows ∧ row.role = Role.holdout ∧ row.lab = key +MAT009.M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = Status.structuralOnlyUnauthenticated +MAT009.M009_R7_rejected_example : (finalize (scan (initial noParent) crossingRows)).status = Status.blocked +MAT009.M009_R7_nonvacuous : + (∃ rows, (finalize (scan (initial noParent) rows)).status = Status.structuralOnlyUnauthenticated) ∧ + ∃ rows, (finalize (scan (initial noParent) rows)).status = Status.blocked +MAT009.Diagnostic.scan_first_owner_sticky (registry : Diagnostic.Registry) (updates : List (String × Diagnostic.Owner)) + (key : String) (first : Diagnostic.Owner) (h : registry key = some first) : + Diagnostic.scan registry updates key = some first +'MAT009.M009_R1_initial' depends on axioms: [propext] +'MAT009.M009_R2_assignment_overwrite' depends on axioms: [propext] +'MAT009.M009_R3_cross_role_trigger' does not depend on any axioms +'MAT009.M009_R4_stickiness' does not depend on any axioms +'MAT009.M009_R5_final_set_intersection' depends on axioms: [propext] +'MAT009.M009_R5_parent_union' depends on axioms: [propext] +'MAT009.M009_R6_cross_trigger_in_finite_scan' depends on axioms: [propext] +'MAT009.M009_R6_arbitrary_finite_scan' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R6_latest_owner' depends on axioms: [propext] +'MAT009.M009_R6_parent_reason_survives' does not depend on any axioms +'MAT009.M009_R6_final_leakage_iff' depends on axioms: [propext, Quot.sound] +'MAT009.M009_R7_accepted_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_rejected_example' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.M009_R7_nonvacuous' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.parent_reason_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Consumer.shared_campaign_blocks_any_scan' depends on axioms: [propext, Classical.choice, Quot.sound] +'MAT009.Diagnostic.scan_first_owner_sticky' depends on axioms: [propext] +'MAT009.Diagnostic.first_owner_not_last_writer' depends on axioms: [propext] diff --git a/formal/sonification/mat009/audit/repair-audit-001/build-03-ExactTypes.stderr b/formal/sonification/mat009/audit/repair-audit-001/build-03-ExactTypes.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/build-03-ExactTypes.stdout b/formal/sonification/mat009/audit/repair-audit-001/build-03-ExactTypes.stdout new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/build-04-LeanAudit.stderr b/formal/sonification/mat009/audit/repair-audit-001/build-04-LeanAudit.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/build-04-LeanAudit.stdout b/formal/sonification/mat009/audit/repair-audit-001/build-04-LeanAudit.stdout new file mode 100644 index 0000000..fc6ae82 --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/build-04-LeanAudit.stdout @@ -0,0 +1,1467 @@ +MAT009_MODULE SplitModel +MAT009_MODULE DiagnosticFirstOwner +MAT009_MODULE TypedConsumer +MAT009_MODULE ExactTypes +MAT009_MODULE LeanAudit +MAT009_IMPORT Init.Prelude +MAT009_IMPORT Init.Coe +MAT009_IMPORT Init.Notation +MAT009_IMPORT Init.Tactics +MAT009_IMPORT Init.SizeOf +MAT009_IMPORT Init.Core +MAT009_IMPORT Init.BinderNameHint +MAT009_IMPORT Init.Control.Basic +MAT009_IMPORT Init.Control.Id +MAT009_IMPORT Init.Control.Except +MAT009_IMPORT Init.Control.State +MAT009_IMPORT Init.Data.Cast +MAT009_IMPORT Init.SimpLemmas +MAT009_IMPORT Init.Data.Zero +MAT009_IMPORT Init.Data.NeZero +MAT009_IMPORT Init.Data.Nat.Basic +MAT009_IMPORT Init.WF +MAT009_IMPORT Init.MetaTypes +MAT009_IMPORT Init.WFTactics +MAT009_IMPORT Init.Data.Nat.Div.Basic +MAT009_IMPORT Init.Data.Int.Basic +MAT009_IMPORT Init.Data.List.Notation +MAT009_IMPORT Init.Data.List.Basic +MAT009_IMPORT Init.Data.Nat.Bitwise.Basic +MAT009_IMPORT Init.Data.Fin.Basic +MAT009_IMPORT Init.Data.BitVec.BasicAux +MAT009_IMPORT Init.Data.UInt.BasicAux +MAT009_IMPORT Init.Data.Char.Basic +MAT009_IMPORT Init.Data.String.Basic +MAT009_IMPORT Init.Data.Format.Basic +MAT009_IMPORT Init.Data.Repr +MAT009_IMPORT Init.Data.Option.Basic +MAT009_IMPORT Init.Data.ToString.Basic +MAT009_IMPORT Init.Util +MAT009_IMPORT Init.GetElem +MAT009_IMPORT Init.Data.List.ToArrayImpl +MAT009_IMPORT Init.Data.Array.Set +MAT009_IMPORT Init.Data.Array.Basic +MAT009_IMPORT Init.Data.Array.Subarray +MAT009_IMPORT Init.Syntax +MAT009_IMPORT Init.Data.Array.GetLit +MAT009_IMPORT Init.Data.Option.BasicAux +MAT009_IMPORT Init.Meta +MAT009_IMPORT Init.Conv +MAT009_IMPORT Init.While +MAT009_IMPORT Init.NotationExtra +MAT009_IMPORT Init.TacticsExtra +MAT009_IMPORT Init.PropLemmas +MAT009_IMPORT Init.Classical +MAT009_IMPORT Init.ByCases +MAT009_IMPORT Init.RCases +MAT009_IMPORT Init.Control.EState +MAT009_IMPORT Init.Control.Reader +MAT009_IMPORT Init.System.ST +MAT009_IMPORT Init.Control.StateRef +MAT009_IMPORT Init.Control.Option +MAT009_IMPORT Init.Control.Lawful.Basic +MAT009_IMPORT Init.Data.ToString.Macro +MAT009_IMPORT Init.Ext +MAT009_IMPORT Init.Control.Lawful.Instances +MAT009_IMPORT Init.Control.Lawful.Lemmas +MAT009_IMPORT Init.Control.Lawful +MAT009_IMPORT Init.Control.StateCps +MAT009_IMPORT Init.Control.ExceptCps +MAT009_IMPORT Init.Control +MAT009_IMPORT Init.Data.Bool +MAT009_IMPORT Init.Data.Int.Lemmas +MAT009_IMPORT Init.Data.Nat.MinMax +MAT009_IMPORT Init.Data.Prod +MAT009_IMPORT Init.Data.RArray +MAT009_IMPORT Init.Data.Nat.Linear +MAT009_IMPORT Init.Data.Nat.Log2 +MAT009_IMPORT Init.Data.Nat.Power2 +MAT009_IMPORT Init.Data.Int.DivMod.Basic +MAT009_IMPORT Init.Data.Int.Order +MAT009_IMPORT Init.Data.Nat.Dvd +MAT009_IMPORT Init.Data.Int.DivMod.Bootstrap +MAT009_IMPORT Init.Omega.Int +MAT009_IMPORT Init.Data.Option.Instances +MAT009_IMPORT Init.Data.BEq +MAT009_IMPORT Init.Data.Option.Lemmas +MAT009_IMPORT Init.Data.List.BasicAux +MAT009_IMPORT Init.Data.List.Control +MAT009_IMPORT Init.BinderPredicates +MAT009_IMPORT Init.Data.List.Lemmas +MAT009_IMPORT Init.Data.List.TakeDrop +MAT009_IMPORT Init.Data.Function +MAT009_IMPORT Init.Data.List.Zip +MAT009_IMPORT Init.Data.Nat.Gcd +MAT009_IMPORT Init.Omega.IntList +MAT009_IMPORT Init.Omega.Coeffs +MAT009_IMPORT Init.Omega.LinearCombo +MAT009_IMPORT Init.Omega.Constraint +MAT009_IMPORT Init.Omega.Logic +MAT009_IMPORT Init.Omega +MAT009_IMPORT Init.Data.Nat.Lemmas +MAT009_IMPORT Init.Data.Int.Pow +MAT009_IMPORT Init.Data.Nat.Simproc +MAT009_IMPORT Init.Data.Nat.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Basic +MAT009_IMPORT Init.Data.Nat.Div.Lemmas +MAT009_IMPORT Init.Data.Int.DivMod.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise.Lemmas +MAT009_IMPORT Init.Data.Int.Bitwise +MAT009_IMPORT Init.Data.BitVec.Basic +MAT009_IMPORT Init.Data.UInt.Basic +MAT009_IMPORT Init.Data.Fin.Log2 +MAT009_IMPORT Init.Data.UInt.Log2 +MAT009_IMPORT Init.Data.Fin.Lemmas +MAT009_IMPORT Init.Data.Nat.Bitwise +MAT009_IMPORT Init.Data.Fin.Bitwise +MAT009_IMPORT Init.Data.Nat.Mod +MAT009_IMPORT Init.Data.Int.LemmasAux +MAT009_IMPORT Init.Data.BitVec.Lemmas +MAT009_IMPORT Init.Data.Fin.Iterate +MAT009_IMPORT Init.Data.BitVec.Folds +MAT009_IMPORT Init.Data.BitVec.Bitblast +MAT009_IMPORT Init.System.Platform +MAT009_IMPORT Init.Data.UInt.Lemmas +MAT009_IMPORT Init.Data.UInt.Bitwise +MAT009_IMPORT Init.Data.UInt +MAT009_IMPORT Init.Data.ByteArray.Basic +MAT009_IMPORT Init.Data.ByteArray +MAT009_IMPORT Init.Data.String.Extra +MAT009_IMPORT Init.Data.Basic +MAT009_IMPORT Init.Data.Nat.Control +MAT009_IMPORT Init.Data.Nat.SOM +MAT009_IMPORT Init.Data.Nat.Lcm +MAT009_IMPORT Init.Data.Char.Lemmas +MAT009_IMPORT Init.Data.List.Sublist +MAT009_IMPORT Init.Data.List.Count +MAT009_IMPORT Init.Data.Subtype +MAT009_IMPORT Init.Data.List.Attach +MAT009_IMPORT Init.Data.List.Pairwise +MAT009_IMPORT Init.Data.List.Range +MAT009_IMPORT Init.Data.List.Find +MAT009_IMPORT Init.Data.List.Nat.TakeDrop +MAT009_IMPORT Init.Data.List.Lex +MAT009_IMPORT Init.Data.String.Lemmas +MAT009_IMPORT Init.Data.String +MAT009_IMPORT Init.Data.SInt.Basic +MAT009_IMPORT Init.Data.List.Erase +MAT009_IMPORT Init.Data.List.Nat.Erase +MAT009_IMPORT Init.Data.List.Nat.Modify +MAT009_IMPORT Init.Data.List.MinMax +MAT009_IMPORT Init.Data.List.Nat.Basic +MAT009_IMPORT Init.Data.List.Monadic +MAT009_IMPORT Init.Data.Fin.Fold +MAT009_IMPORT Init.Data.List.OfFn +MAT009_IMPORT Init.Data.Array.Mem +MAT009_IMPORT Init.Data.List.Nat.BEq +MAT009_IMPORT Init.Data.Array.DecidableEq +MAT009_IMPORT Init.Data.Range.Basic +MAT009_IMPORT Init.Data.Range.Lemmas +MAT009_IMPORT Init.Data.Range +MAT009_IMPORT Init.Data.Array.Lex.Basic +MAT009_IMPORT Init.Data.Array.Bootstrap +MAT009_IMPORT Init.Data.List.Impl +MAT009_IMPORT Init.Data.List.Nat.InsertIdx +MAT009_IMPORT Init.Data.List.ToArray +MAT009_IMPORT Init.Data.Array.Lemmas +MAT009_IMPORT Init.Data.List.Nat.Count +MAT009_IMPORT Init.Data.Array.Count +MAT009_IMPORT Init.Data.Array.Attach +MAT009_IMPORT Init.Data.Array.OfFn +MAT009_IMPORT Init.Data.List.Nat.Range +MAT009_IMPORT Init.Data.Option.List +MAT009_IMPORT Init.Data.Option.Attach +MAT009_IMPORT Init.Data.List.MapIdx +MAT009_IMPORT Init.Data.Array.MapIdx +MAT009_IMPORT Init.Data.Array.InsertIdx +MAT009_IMPORT Init.Data.Array.TakeDrop +MAT009_IMPORT Init.Data.Array.Zip +MAT009_IMPORT Init.Data.Array.Range +MAT009_IMPORT Init.Data.Stream +MAT009_IMPORT Init.Data.Vector.Basic +MAT009_IMPORT Init.Data.List.Nat.Find +MAT009_IMPORT Init.Data.Array.Find +MAT009_IMPORT Init.Data.Vector.Lemmas +MAT009_IMPORT Init.Data.Array.Lex.Lemmas +MAT009_IMPORT Init.Data.Vector.Lex +MAT009_IMPORT Init.Data.Vector.Attach +MAT009_IMPORT Init.Data.Vector.MapIdx +MAT009_IMPORT Init.Data.Vector.Count +MAT009_IMPORT Init.Data.Vector.DecidableEq +MAT009_IMPORT Init.Data.Vector.Zip +MAT009_IMPORT Init.Data.Vector.OfFn +MAT009_IMPORT Init.Data.Vector.Range +MAT009_IMPORT Init.Data.Array.Erase +MAT009_IMPORT Init.Data.Vector.Erase +MAT009_IMPORT Init.Data.Array.Monadic +MAT009_IMPORT Init.Data.Vector.Monadic +MAT009_IMPORT Init.Data.Vector.InsertIdx +MAT009_IMPORT Init.Data.List.FinRange +MAT009_IMPORT Init.Data.Array.FinRange +MAT009_IMPORT Init.Data.Vector.FinRange +MAT009_IMPORT Init.Data.Array.Extract +MAT009_IMPORT Init.Data.Vector.Extract +MAT009_IMPORT Init.Data.Vector +MAT009_IMPORT Init.Data.Ord +MAT009_IMPORT Init.Data.Nat.Compare +MAT009_IMPORT Init.Data.Nat.Fold +MAT009_IMPORT Init.Data.Nat +MAT009_IMPORT Init.Data.BitVec +MAT009_IMPORT Init.Data.Char +MAT009_IMPORT Init.Data.List.Nat.Pairwise +MAT009_IMPORT Init.Data.List.Nat.Sublist +MAT009_IMPORT Init.Data.List.Perm +MAT009_IMPORT Init.Data.List.Nat.Perm +MAT009_IMPORT Init.Data.List.Nat +MAT009_IMPORT Init.Data.List.Sort.Basic +MAT009_IMPORT Init.Data.List.Sort.Lemmas +MAT009_IMPORT Init.Data.List.Sort.Impl +MAT009_IMPORT Init.Data.List.Sort +MAT009_IMPORT Init.Data.List +MAT009_IMPORT Init.Data.Int.DivMod +MAT009_IMPORT Init.Data.Int.Gcd +MAT009_IMPORT Init.Data.Int.Cooper +MAT009_IMPORT Init.Data.AC +MAT009_IMPORT Init.Data.Int.Linear +MAT009_IMPORT Init.Data.Int.OfNat +MAT009_IMPORT Init.Data.Int +MAT009_IMPORT Init.Data.Array.QSort +MAT009_IMPORT Init.Data.Array.BinSearch +MAT009_IMPORT Init.Data.Array.InsertionSort +MAT009_IMPORT Init.Data.Array.BasicAux +MAT009_IMPORT Init.Data.Array.Perm +MAT009_IMPORT Init.Data.Array.Lex +MAT009_IMPORT Init.Data.Array +MAT009_IMPORT Init.Data.Array.Subarray.Split +MAT009_IMPORT Init.Data.Float +MAT009_IMPORT Init.Data.FloatArray.Basic +MAT009_IMPORT Init.Data.FloatArray +MAT009_IMPORT Init.Data.Fin +MAT009_IMPORT Init.Data.SInt.Float +MAT009_IMPORT Init.Data.Float32 +MAT009_IMPORT Init.Data.SInt.Float32 +MAT009_IMPORT Init.Data.SInt.Lemmas +MAT009_IMPORT Init.Data.SInt.Bitwise +MAT009_IMPORT Init.Data.SInt +MAT009_IMPORT Init.Data.Option.Monadic +MAT009_IMPORT Init.Data.Option +MAT009_IMPORT Init.System.IOError +MAT009_IMPORT Init.System.FilePath +MAT009_IMPORT Init.System.IO +MAT009_IMPORT Init.Data.Random +MAT009_IMPORT Init.Data.ToString +MAT009_IMPORT Init.Data.Hashable +MAT009_IMPORT Init.Data.OfScientific +MAT009_IMPORT Init.Data.Format.Macro +MAT009_IMPORT Init.Data.Format.Instances +MAT009_IMPORT Init.Data.Format.Syntax +MAT009_IMPORT Init.Data.Format +MAT009_IMPORT Init.Data.Queue +MAT009_IMPORT Init.System.Promise +MAT009_IMPORT Init.System.Mutex +MAT009_IMPORT Init.Data.Channel +MAT009_IMPORT Init.Data.Sum.Basic +MAT009_IMPORT Init.Data.Sum.Lemmas +MAT009_IMPORT Init.Data.Sum +MAT009_IMPORT Init.Data.ULift +MAT009_IMPORT Init.Data.PLift +MAT009_IMPORT Init.Data +MAT009_IMPORT Init.System.Uri +MAT009_IMPORT Init.System +MAT009_IMPORT Init.Dynamic +MAT009_IMPORT Init.ShareCommon +MAT009_IMPORT Init.Hints +MAT009_IMPORT Init.Guard +MAT009_IMPORT Init.Simproc +MAT009_IMPORT Init.SizeOfLemmas +MAT009_IMPORT Init.MacroTrace +MAT009_IMPORT Init.Grind.Norm +MAT009_IMPORT Init.Grind.Tactics +MAT009_IMPORT Init.Grind.Util +MAT009_IMPORT Init.Grind.Lemmas +MAT009_IMPORT Init.Grind.Cases +MAT009_IMPORT Init.Grind.Propagator +MAT009_IMPORT Init.Grind.Offset +MAT009_IMPORT Init.Grind.PP +MAT009_IMPORT Init.Grind +MAT009_IMPORT Init.Internal.Order.Basic +MAT009_IMPORT Init.Internal.Order.Lemmas +MAT009_IMPORT Init.Internal.Order.Tactic +MAT009_IMPORT Init.Internal.Order +MAT009_IMPORT Init.Internal +MAT009_IMPORT Init.Try +MAT009_IMPORT Init.Task +MAT009_IMPORT Init +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Basic +MAT009_IMPORT Std.Data.DHashMap.RawDef +MAT009_IMPORT Std.Data.Internal.List.Defs +MAT009_IMPORT Std.Data.DHashMap.Internal.Index +MAT009_IMPORT Std.Data.DHashMap.Internal.Defs +MAT009_IMPORT Std.Data.DHashMap.Raw +MAT009_IMPORT Std.Data.DHashMap.Basic +MAT009_IMPORT Std.Data.DHashMap.Internal.Raw +MAT009_IMPORT Std.Classes.Ord +MAT009_IMPORT Std.Data.Internal.List.Associative +MAT009_IMPORT Std.Data.DHashMap.Internal.HashesTo +MAT009_IMPORT Std.Data.DHashMap.Internal.AssocList.Lemmas +MAT009_IMPORT Std.Data.DHashMap.Internal.Model +MAT009_IMPORT Std.Data.DHashMap.Internal.WF +MAT009_IMPORT Std.Data.DHashMap.Internal.RawLemmas +MAT009_IMPORT Std.Data.DHashMap.AdditionalOperations +MAT009_IMPORT Std.Data.DHashMap.Lemmas +MAT009_IMPORT Std.Data.DHashMap +MAT009_IMPORT Std.Data.HashMap.Basic +MAT009_IMPORT Std.Data.HashMap.Raw +MAT009_IMPORT Std.Data.HashMap.AdditionalOperations +MAT009_IMPORT Std.Data.HashMap.Lemmas +MAT009_IMPORT Std.Data.HashMap +MAT009_IMPORT Std.Data.HashSet.Basic +MAT009_IMPORT Std.Data.HashSet.Lemmas +MAT009_IMPORT Std.Data.HashSet +MAT009_IMPORT Std.Data.DTreeMap.Internal.Def +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balanced +MAT009_IMPORT Std.Data.DTreeMap.Internal.Balancing +MAT009_IMPORT Std.Data.Internal.Cut +MAT009_IMPORT Std.Data.DTreeMap.Internal.Ordered +MAT009_IMPORT Std.Data.DTreeMap.Internal.Queries +MAT009_IMPORT Std.Data.DTreeMap.Internal.Operations +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Defs +MAT009_IMPORT Std.Data.DTreeMap.Basic +MAT009_IMPORT Std.Data.DTreeMap.Raw.Basic +MAT009_IMPORT Std.Data.DTreeMap.Internal.Cell +MAT009_IMPORT Std.Data.DTreeMap.Internal.Model +MAT009_IMPORT Std.Data.DTreeMap.Internal.WF.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap +MAT009_IMPORT Std.Data.TreeMap.Basic +MAT009_IMPORT Std.Data.TreeMap.Raw.Basic +MAT009_IMPORT Std.Data.TreeMap.AdditionalOperations +MAT009_IMPORT Std.Data.TreeMap +MAT009_IMPORT Std.Data.TreeSet.Basic +MAT009_IMPORT Std.Data.TreeSet.Raw.Basic +MAT009_IMPORT Std.Data.TreeSet.AdditionalOperations +MAT009_IMPORT Std.Data.DTreeMap.Internal.Lemmas +MAT009_IMPORT Std.Data.DTreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeMap.Lemmas +MAT009_IMPORT Std.Data.TreeSet.Lemmas +MAT009_IMPORT Std.Data.TreeSet +MAT009_IMPORT Std.Data.DHashMap.RawLemmas +MAT009_IMPORT Std.Data.HashMap.RawLemmas +MAT009_IMPORT Std.Data.HashSet.Raw +MAT009_IMPORT Std.Data.HashSet.RawLemmas +MAT009_IMPORT Std.Data +MAT009_IMPORT Std.Sat.AIG.Basic +MAT009_IMPORT Std.Sat.AIG.LawfulOperator +MAT009_IMPORT Std.Sat.AIG.Lemmas +MAT009_IMPORT Std.Sat.AIG.Cached +MAT009_IMPORT Std.Sat.AIG.CachedLemmas +MAT009_IMPORT Std.Sat.AIG.CachedGates +MAT009_IMPORT Std.Sat.AIG.CachedGatesLemmas +MAT009_IMPORT Std.Sat.CNF.Literal +MAT009_IMPORT Std.Sat.CNF.Basic +MAT009_IMPORT Std.Sat.CNF.Relabel +MAT009_IMPORT Std.Sat.CNF.RelabelFin +MAT009_IMPORT Std.Sat.CNF.Dimacs +MAT009_IMPORT Std.Sat.CNF +MAT009_IMPORT Std.Sat.AIG.CNF +MAT009_IMPORT Std.Sat.AIG.Relabel +MAT009_IMPORT Std.Sat.AIG.RelabelNat +MAT009_IMPORT Std.Sat.AIG.RefVec +MAT009_IMPORT Std.Sat.AIG.LawfulVecOperator +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Map +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Zip +MAT009_IMPORT Std.Sat.AIG.RefVecOperator.Fold +MAT009_IMPORT Std.Sat.AIG.RefVecOperator +MAT009_IMPORT Std.Sat.AIG.If +MAT009_IMPORT Std.Sat.AIG +MAT009_IMPORT Std.Sat +MAT009_IMPORT Std.Sync.Basic +MAT009_IMPORT Std.Sync.Mutex +MAT009_IMPORT Std.Sync.Channel +MAT009_IMPORT Std.Sync.RecursiveMutex +MAT009_IMPORT Std.Sync.Barrier +MAT009_IMPORT Std.Sync +MAT009_IMPORT Std.Time.Internal.Bounded +MAT009_IMPORT Std.Internal.Rat +MAT009_IMPORT Std.Time.Internal.UnitVal +MAT009_IMPORT Std.Time.Internal +MAT009_IMPORT Std.Time.Time.Unit.Nanosecond +MAT009_IMPORT Std.Time.Time.Unit.Second +MAT009_IMPORT Std.Time.Time.Unit.Minute +MAT009_IMPORT Std.Time.Time.Unit.Hour +MAT009_IMPORT Std.Time.Time.Unit.Millisecond +MAT009_IMPORT Std.Time.Time.Unit.Basic +MAT009_IMPORT Std.Time.Time.Basic +MAT009_IMPORT Std.Time.Time.HourMarker +MAT009_IMPORT Std.Time.Time.PlainTime +MAT009_IMPORT Std.Time.Time +MAT009_IMPORT Std.Time.Date.Unit.Day +MAT009_IMPORT Std.Time.Date.Unit.Month +MAT009_IMPORT Std.Time.Date.Unit.Year +MAT009_IMPORT Std.Time.Date.Unit.Weekday +MAT009_IMPORT Std.Time.Date.Unit.Week +MAT009_IMPORT Std.Time.Date.Unit.Basic +MAT009_IMPORT Std.Time.Date.ValidDate +MAT009_IMPORT Std.Time.Date.Basic +MAT009_IMPORT Std.Time.Date.PlainDate +MAT009_IMPORT Std.Time.Date +MAT009_IMPORT Std.Time.Duration +MAT009_IMPORT Std.Time.DateTime.Timestamp +MAT009_IMPORT Std.Time.DateTime.PlainDateTime +MAT009_IMPORT Std.Time.DateTime +MAT009_IMPORT Std.Time.Zoned.Offset +MAT009_IMPORT Std.Time.Zoned.TimeZone +MAT009_IMPORT Std.Time.Zoned.DateTime +MAT009_IMPORT Std.Time.Zoned.ZoneRules +MAT009_IMPORT Std.Time.Zoned.ZonedDateTime +MAT009_IMPORT Std.Internal.Parsec.Basic +MAT009_IMPORT Std.Internal.Parsec.String +MAT009_IMPORT Std.Internal.Parsec.ByteArray +MAT009_IMPORT Std.Internal.Parsec +MAT009_IMPORT Std.Time.Zoned.Database.TzIf +MAT009_IMPORT Std.Time.Zoned.Database.Basic +MAT009_IMPORT Std.Time.Zoned.Database.TZdb +MAT009_IMPORT Std.Time.Zoned.Database.Windows +MAT009_IMPORT Std.Time.Zoned.Database +MAT009_IMPORT Std.Time.Zoned +MAT009_IMPORT Std.Time.Format.Basic +MAT009_IMPORT Std.Time.Notation.Spec +MAT009_IMPORT Std.Time.Format +MAT009_IMPORT Std.Time.Notation +MAT009_IMPORT Std.Time +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BoolExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Basic +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Eq +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Carry +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Ult +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.GetLsbD +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Const +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Append +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Replicate +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Extract +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Mul +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Sub +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ZeroExtend +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Bool +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Canonicalize +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.BitVec +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Udiv +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Umod +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Pred +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast.BVExpr +MAT009_IMPORT Std.Tactic.BVDecide.Bitblast +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Entails +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.PosFin +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Assignment +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Clause +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Class +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.CNF +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula.Instance +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Formula +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Convert +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATChecker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.Actions +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Checker +MAT009_IMPORT Std.Tactic.BVDecide.LRAT.Parser +MAT009_IMPORT Std.Tactic.BVDecide.LRAT +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Equal +MAT009_IMPORT Std.Tactic.BVDecide.Normalize.Prop +MAT009_IMPORT Std.Tactic.BVDecide.Normalize +MAT009_IMPORT Std.Tactic.BVDecide.Reflect +MAT009_IMPORT Std.Tactic.BVDecide.Syntax +MAT009_IMPORT Std.Tactic.BVDecide +MAT009_IMPORT Std.Tactic +MAT009_IMPORT Std.Internal.Async.Basic +MAT009_IMPORT Std.Internal.UV.Loop +MAT009_IMPORT Std.Internal.UV.Timer +MAT009_IMPORT Std.Net.Addr +MAT009_IMPORT Std.Net +MAT009_IMPORT Std.Internal.UV.TCP +MAT009_IMPORT Std.Internal.UV.UDP +MAT009_IMPORT Std.Internal.UV +MAT009_IMPORT Std.Internal.Async.Timer +MAT009_IMPORT Std.Internal.Async.TCP +MAT009_IMPORT Std.Internal.Async.UDP +MAT009_IMPORT Std.Internal.Async +MAT009_IMPORT Std.Internal +MAT009_IMPORT Std +MAT009_IMPORT SplitModel +MAT009_IMPORT DiagnosticFirstOwner +MAT009_IMPORT TypedConsumer +MAT009_IMPORT ExactTypes +MAT009_IMPORT Lean.Data.AssocList +MAT009_IMPORT Lean.ImportingFlag +MAT009_IMPORT Lean.Data.KVMap +MAT009_IMPORT Lean.Data.RBMap +MAT009_IMPORT Lean.Data.RBTree +MAT009_IMPORT Lean.Data.PersistentHashMap +MAT009_IMPORT Lean.Data.SMap +MAT009_IMPORT Lean.Data.SSet +MAT009_IMPORT Lean.Data.Name +MAT009_IMPORT Lean.Data.NameMap +MAT009_IMPORT Lean.Data.Options +MAT009_IMPORT Lean.Data.Format +MAT009_IMPORT Lean.Data.Json.Basic +MAT009_IMPORT Lean.Data.Json.Parser +MAT009_IMPORT Lean.Data.Json.Printer +MAT009_IMPORT Lean.Data.Json.FromToJson +MAT009_IMPORT Lean.Data.Json.Stream +MAT009_IMPORT Lean.Syntax +MAT009_IMPORT Lean.Data.Json.Elab +MAT009_IMPORT Lean.Data.Json +MAT009_IMPORT Lean.Data.JsonRpc +MAT009_IMPORT Lean.Data.LBool +MAT009_IMPORT Lean.Data.LOption +MAT009_IMPORT Lean.Data.Lsp.Basic +MAT009_IMPORT Lean.Data.Lsp.CancelParams +MAT009_IMPORT Lean.Data.Lsp.TextSync +MAT009_IMPORT Lean.Data.Lsp.LanguageFeatures +MAT009_IMPORT Lean.Data.PersistentHashSet +MAT009_IMPORT Lean.Hygiene +MAT009_IMPORT Lean.Level +MAT009_IMPORT Lean.Expr +MAT009_IMPORT Lean.ToLevel +MAT009_IMPORT Lean.ToExpr +MAT009_IMPORT Lean.Data.Position +MAT009_IMPORT Lean.Data.DeclarationRange +MAT009_IMPORT Lean.Data.PrefixTree +MAT009_IMPORT Lean.Data.NameTrie +MAT009_IMPORT Lean.Declaration +MAT009_IMPORT Lean.Data.PersistentArray +MAT009_IMPORT Lean.LocalContext +MAT009_IMPORT Lean.Util.Path +MAT009_IMPORT Lean.Util.FindExpr +MAT009_IMPORT Lean.Util.Profile +MAT009_IMPORT Lean.Util.PtrSet +MAT009_IMPORT Lean.Util.ReplaceExpr +MAT009_IMPORT Lean.Util.InstantiateLevelParams +MAT009_IMPORT Lean.Util.FoldConsts +MAT009_IMPORT Lean.PrivateName +MAT009_IMPORT Lean.LoadDynlib +MAT009_IMPORT Lean.Environment +MAT009_IMPORT Lean.Data.OpenDecl +MAT009_IMPORT Lean.Util.MonadCache +MAT009_IMPORT Lean.MetavarContext +MAT009_IMPORT Lean.Server.Rpc.Basic +MAT009_IMPORT Lean.Widget.Types +MAT009_IMPORT Lean.Elab.InfoTree.Types +MAT009_IMPORT Lean.Util.PPExt +MAT009_IMPORT Lean.Util.Sorry +MAT009_IMPORT Lean.Message +MAT009_IMPORT Lean.InternalExceptionId +MAT009_IMPORT Lean.Exception +MAT009_IMPORT Lean.Log +MAT009_IMPORT Lean.AuxRecursor +MAT009_IMPORT Lean.Compiler.Old +MAT009_IMPORT Lean.MonadEnv +MAT009_IMPORT Lean.DeclarationRange +MAT009_IMPORT Lean.Data.Lsp.Utf16 +MAT009_IMPORT Lean.Data.Lsp.Diagnostics +MAT009_IMPORT Lean.Data.Lsp.CodeActions +MAT009_IMPORT Lean.Data.Lsp.Capabilities +MAT009_IMPORT Lean.Data.Lsp.Client +MAT009_IMPORT Lean.Data.Lsp.Communication +MAT009_IMPORT Lean.Data.Lsp.Extra +MAT009_IMPORT Lean.Data.Lsp.Workspace +MAT009_IMPORT Lean.Data.Lsp.InitShutdown +MAT009_IMPORT Lean.Data.Lsp.Internal +MAT009_IMPORT Lean.Data.Lsp.Ipc +MAT009_IMPORT Lean.Data.Lsp.Window +MAT009_IMPORT Lean.Data.Lsp +MAT009_IMPORT Lean.Data.Trie +MAT009_IMPORT Lean.Data.Xml.Basic +MAT009_IMPORT Lean.Data.Xml.Parser +MAT009_IMPORT Lean.Data.Xml +MAT009_IMPORT Lean.Data.RArray +MAT009_IMPORT Lean.Data +MAT009_IMPORT Lean.Util.RecDepth +MAT009_IMPORT Lean.Elab.Exception +MAT009_IMPORT Lean.Util.Trace +MAT009_IMPORT Lean.Modifiers +MAT009_IMPORT Lean.Namespace +MAT009_IMPORT Lean.ResolveName +MAT009_IMPORT Lean.DocString.Links +MAT009_IMPORT Lean.DocString.Extension +MAT009_IMPORT Lean.Parser.Types +MAT009_IMPORT Lean.Language.Basic +MAT009_IMPORT Lean.CoreM +MAT009_IMPORT Lean.Attributes +MAT009_IMPORT Lean.Compiler.InlineAttrs +MAT009_IMPORT Lean.Class +MAT009_IMPORT Lean.ScopedEnvExtension +MAT009_IMPORT Lean.ReducibilityAttrs +MAT009_IMPORT Lean.Util.MonadBacktrack +MAT009_IMPORT Lean.Meta.TransparencyMode +MAT009_IMPORT Lean.Meta.Basic +MAT009_IMPORT Lean.Compiler.Specialize +MAT009_IMPORT Lean.Compiler.ConstFolding +MAT009_IMPORT Lean.Compiler.ClosedTermCache +MAT009_IMPORT Lean.ProjFns +MAT009_IMPORT Lean.Compiler.ExternAttr +MAT009_IMPORT Lean.Meta.InferType +MAT009_IMPORT Lean.Meta.PPGoal +MAT009_IMPORT Lean.ReservedNameAction +MAT009_IMPORT Lean.Elab.InfoTree.Main +MAT009_IMPORT Lean.Elab.InfoTree +MAT009_IMPORT Lean.Compiler.ImplementedByAttr +MAT009_IMPORT Lean.Compiler.NeverExtractAttr +MAT009_IMPORT Lean.Compiler.IR.Basic +MAT009_IMPORT Lean.Compiler.IR.Format +MAT009_IMPORT Lean.Compiler.IR.CompilerM +MAT009_IMPORT Lean.Compiler.IR.FreeVars +MAT009_IMPORT Lean.Compiler.IR.NormIds +MAT009_IMPORT Lean.Compiler.IR.PushProj +MAT009_IMPORT Lean.Compiler.IR.ElimDeadVars +MAT009_IMPORT Lean.Compiler.IR.SimpCase +MAT009_IMPORT Lean.Compiler.IR.LiveVars +MAT009_IMPORT Lean.Compiler.IR.ResetReuse +MAT009_IMPORT Lean.Compiler.IR.Checker +MAT009_IMPORT Lean.Compiler.ExportAttr +MAT009_IMPORT Lean.Compiler.IR.Borrow +MAT009_IMPORT Lean.Runtime +MAT009_IMPORT Lean.Compiler.IR.Boxing +MAT009_IMPORT Lean.Compiler.IR.RC +MAT009_IMPORT Lean.Compiler.IR.ExpandResetReuse +MAT009_IMPORT Lean.Compiler.IR.UnboxResult +MAT009_IMPORT Lean.Compiler.IR.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.NameMangling +MAT009_IMPORT Lean.AddDecl +MAT009_IMPORT Lean.Compiler.InitAttr +MAT009_IMPORT Lean.Compiler.IR.EmitUtil +MAT009_IMPORT Lean.Compiler.IR.EmitC +MAT009_IMPORT Lean.Compiler.IR.CtorLayout +MAT009_IMPORT Lean.Compiler.IR.Sorry +MAT009_IMPORT Lean.Compiler.IR +MAT009_IMPORT Lean.Util.Recognizers +MAT009_IMPORT Lean.Compiler.CSimpAttr +MAT009_IMPORT Lean.Compiler.FFI +MAT009_IMPORT Lean.Compiler.NoncomputableAttr +MAT009_IMPORT Lean.Meta.GlobalInstances +MAT009_IMPORT Lean.Structure +MAT009_IMPORT Lean.Util.SafeExponentiation +MAT009_IMPORT Lean.Meta.GetUnfoldableConst +MAT009_IMPORT Lean.Meta.FunInfo +MAT009_IMPORT Lean.Meta.NatInstTesters +MAT009_IMPORT Lean.Meta.Offset +MAT009_IMPORT Lean.Meta.LitValues +MAT009_IMPORT Lean.Meta.CtorRecognizer +MAT009_IMPORT Lean.Meta.Match.MatcherInfo +MAT009_IMPORT Lean.Meta.Match.MatchPatternAttr +MAT009_IMPORT Lean.Meta.Transform +MAT009_IMPORT Lean.Meta.WHNF +MAT009_IMPORT Lean.Meta.DiscrTreeTypes +MAT009_IMPORT Lean.Meta.DiscrTree +MAT009_IMPORT Lean.Util.CollectMVars +MAT009_IMPORT Lean.Meta.CollectMVars +MAT009_IMPORT Lean.Meta.Instances +MAT009_IMPORT Lean.Compiler.LCNF.Types +MAT009_IMPORT Lean.Compiler.LCNF.Basic +MAT009_IMPORT Lean.Compiler.LCNF.AlphaEqv +MAT009_IMPORT Lean.Compiler.LCNF.LCtx +MAT009_IMPORT Lean.Compiler.LCNF.ConfigOptions +MAT009_IMPORT Lean.Compiler.LCNF.CompilerM +MAT009_IMPORT Lean.Compiler.LCNF.PassManager +MAT009_IMPORT Lean.Compiler.LCNF.PhaseExt +MAT009_IMPORT Lean.Compiler.LCNF.BaseTypes +MAT009_IMPORT Lean.Compiler.LCNF.Util +MAT009_IMPORT Lean.Compiler.LCNF.MonoTypes +MAT009_IMPORT Lean.Compiler.LCNF.OtherDecl +MAT009_IMPORT Lean.Compiler.LCNF.InferType +MAT009_IMPORT Lean.Compiler.LCNF.Bind +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Options +MAT009_IMPORT Lean.Compiler.LCNF.Internalize +MAT009_IMPORT Lean.Compiler.LCNF.PrettyPrinter +MAT009_IMPORT Lean.Compiler.LCNF.CompatibleTypes +MAT009_IMPORT Lean.Compiler.LCNF.Check +MAT009_IMPORT Lean.Compiler.LCNF.ToExpr +MAT009_IMPORT Lean.Compiler.LCNF.CSE +MAT009_IMPORT Lean.Compiler.LCNF.DependsOn +MAT009_IMPORT Lean.Compiler.LCNF.ElimDead +MAT009_IMPORT Lean.Compiler.LCNF.FixedParams +MAT009_IMPORT Lean.Compiler.LCNF.PullFunDecls +MAT009_IMPORT Lean.Compiler.LCNF.FVarUtil +MAT009_IMPORT Lean.Compiler.LCNF.ScopeM +MAT009_IMPORT Lean.Compiler.LCNF.JoinPoints +MAT009_IMPORT Lean.Util.CollectLevelParams +MAT009_IMPORT Lean.Compiler.LCNF.Level +MAT009_IMPORT Lean.Compiler.Options +MAT009_IMPORT Lean.Compiler.LCNF.PullLetDecls +MAT009_IMPORT Lean.Compiler.LCNF.ReduceJpArity +MAT009_IMPORT Lean.Compiler.LCNF.Renaming +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Basic +MAT009_IMPORT Lean.Compiler.LCNF.Simp.FunDeclInfo +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DiscrM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.JpCases +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Config +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpM +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineCandidate +MAT009_IMPORT Lean.Compiler.LCNF.Simp.InlineProj +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Used +MAT009_IMPORT Lean.Compiler.LCNF.Simp.DefaultAlt +MAT009_IMPORT Lean.Compiler.LCNF.Simp.SimpValue +MAT009_IMPORT Lean.Compiler.LCNF.Simp.ConstantFold +MAT009_IMPORT Lean.Compiler.LCNF.Simp.Main +MAT009_IMPORT Lean.Compiler.LCNF.Simp +MAT009_IMPORT Lean.Compiler.LCNF.SpecInfo +MAT009_IMPORT Lean.Compiler.LCNF.MonadScope +MAT009_IMPORT Lean.Util.ForEachExprWhere +MAT009_IMPORT Lean.Compiler.LCNF.Closure +MAT009_IMPORT Lean.Compiler.LCNF.Specialize +MAT009_IMPORT Lean.Compiler.LCNF.ToMono +MAT009_IMPORT Lean.Compiler.LCNF.DeclHash +MAT009_IMPORT Lean.Compiler.LCNF.AuxDeclCache +MAT009_IMPORT Lean.Compiler.LCNF.LambdaLifting +MAT009_IMPORT Lean.Compiler.LCNF.FloatLetIn +MAT009_IMPORT Lean.Compiler.LCNF.ReduceArity +MAT009_IMPORT Lean.Compiler.LCNF.ElimDeadBranches +MAT009_IMPORT Lean.Compiler.LCNF.Passes +MAT009_IMPORT Lean.Compiler.BorrowedAnnotation +MAT009_IMPORT Lean.Compiler.LCNF.ToLCNF +MAT009_IMPORT Lean.Compiler.LCNF.ToDecl +MAT009_IMPORT Lean.Compiler.LCNF.Main +MAT009_IMPORT Lean.Compiler.LCNF.Testing +MAT009_IMPORT Lean.Compiler.LCNF +MAT009_IMPORT Lean.Compiler.Main +MAT009_IMPORT Lean.Compiler.AtMostOnce +MAT009_IMPORT Lean.Compiler +MAT009_IMPORT Lean.Parser.Basic +MAT009_IMPORT Lean.BuiltinDocAttr +MAT009_IMPORT Lean.Parser.Extension +MAT009_IMPORT Lean.Parser.StrInterpolation +MAT009_IMPORT Lean.ParserCompiler.Attribute +MAT009_IMPORT Lean.KeyedDeclsAttribute +MAT009_IMPORT Lean.PrettyPrinter.Basic +MAT009_IMPORT Lean.PrettyPrinter.Parenthesizer +MAT009_IMPORT Lean.PrettyPrinter.Formatter +MAT009_IMPORT Lean.Parser.Extra +MAT009_IMPORT Lean.Parser.Level +MAT009_IMPORT Lean.Parser.Attr +MAT009_IMPORT Lean.Parser.Term.Doc +MAT009_IMPORT Lean.Parser.Term +MAT009_IMPORT Lean.Parser.Tactic.Doc +MAT009_IMPORT Lean.Parser.Tactic +MAT009_IMPORT Lean.Parser.Do +MAT009_IMPORT Lean.Parser.Command +MAT009_IMPORT Lean.Parser.Module +MAT009_IMPORT Lean.Parser.Syntax +MAT009_IMPORT Lean.Parser +MAT009_IMPORT Lean.Util.Paths +MAT009_IMPORT Lean.Elab.Import +MAT009_IMPORT Lean.Elab.Config +MAT009_IMPORT Lean.SubExpr +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.SubExpr +MAT009_IMPORT Lean.Meta.AbstractMVars +MAT009_IMPORT Lean.Meta.Sorry +MAT009_IMPORT Lean.Meta.Check +MAT009_IMPORT Lean.Meta.SynthInstance +MAT009_IMPORT Lean.Util.FindMVar +MAT009_IMPORT Lean.Util.FindLevelMVar +MAT009_IMPORT Lean.Util.ReplaceLevel +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Attributes +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.FieldNotation +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.TopDownAnalyze +MAT009_IMPORT Lean.Meta.DecLevel +MAT009_IMPORT Lean.Meta.AppBuilder +MAT009_IMPORT Lean.Meta.Coe +MAT009_IMPORT Lean.Util.CollectLevelMVars +MAT009_IMPORT Lean.Linter.Basic +MAT009_IMPORT Lean.Linter.Deprecated +MAT009_IMPORT Lean.Elab.AutoBound +MAT009_IMPORT Lean.Elab.Level +MAT009_IMPORT Lean.Elab.Util +MAT009_IMPORT Lean.Elab.Attributes +MAT009_IMPORT Lean.DocString.Add +MAT009_IMPORT Lean.Elab.DeclModifiers +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationHint +MAT009_IMPORT Lean.Elab.DeclarationRange +MAT009_IMPORT Lean.Elab.InfoTree.InlayHints +MAT009_IMPORT Lean.Elab.Term +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Basic +MAT009_IMPORT Lean.Meta.CoeAttr +MAT009_IMPORT Lean.Meta.Structure +MAT009_IMPORT Lean.PrettyPrinter.Delaborator.Builtins +MAT009_IMPORT Lean.PrettyPrinter.Delaborator +MAT009_IMPORT Lean.Meta.ReduceEval +MAT009_IMPORT Lean.ParserCompiler +MAT009_IMPORT Lean.Util.NumObjs +MAT009_IMPORT Lean.Util.ShareCommon +MAT009_IMPORT Lean.PrettyPrinter +MAT009_IMPORT Lean.Meta.Diagnostics +MAT009_IMPORT Lean.Elab.Quotation.Util +MAT009_IMPORT Lean.Elab.Quotation.Precheck +MAT009_IMPORT Lean.Elab.BindersUtil +MAT009_IMPORT Lean.Meta.Tactic.Util +MAT009_IMPORT Lean.Util.ForEachExpr +MAT009_IMPORT Lean.Util.OccursCheck +MAT009_IMPORT Lean.Elab.Tactic.Basic +MAT009_IMPORT Lean.Elab.SyntheticMVars +MAT009_IMPORT Lean.Elab.Binders +MAT009_IMPORT Lean.Elab.SetOption +MAT009_IMPORT Lean.Elab.Command +MAT009_IMPORT Lean.Util.CollectFVars +MAT009_IMPORT Lean.HeadIndex +MAT009_IMPORT Lean.Meta.KAbstract +MAT009_IMPORT Lean.Meta.Tactic.ElimInfo +MAT009_IMPORT Lean.Elab.Arg +MAT009_IMPORT Lean.Elab.RecAppSyntax +MAT009_IMPORT Lean.Elab.App +MAT009_IMPORT Lean.Elab.Syntax +MAT009_IMPORT Lean.Elab.MacroArgUtil +MAT009_IMPORT Lean.Meta.Eqns +MAT009_IMPORT Lean.Meta.Tactic.AuxLemma +MAT009_IMPORT Lean.DocString +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpTheorems +MAT009_IMPORT Lean.Meta.CongrTheorems +MAT009_IMPORT Lean.Meta.MatchUtil +MAT009_IMPORT Lean.Meta.Tactic.Clear +MAT009_IMPORT Lean.Meta.Tactic.Revert +MAT009_IMPORT Lean.Meta.Tactic.Intro +MAT009_IMPORT Lean.Meta.Tactic.FVarSubst +MAT009_IMPORT Lean.Meta.Tactic.Assert +MAT009_IMPORT Lean.Meta.Tactic.Replace +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpCongrTheorems +MAT009_IMPORT Lean.Meta.Tactic.Simp.Types +MAT009_IMPORT Lean.Meta.Tactic.Simp.Simproc +MAT009_IMPORT Lean.Meta.Tactic.Simp.Attr +MAT009_IMPORT Lean.Meta.Tactic.Simp.RegisterCommand +MAT009_IMPORT Lean.Server.InfoUtils +MAT009_IMPORT Lean.Linter.Util +MAT009_IMPORT Lean.Linter.MissingDocs +MAT009_IMPORT Lean.Elab.BinderPredicates +MAT009_IMPORT Lean.Elab.LetRec +MAT009_IMPORT Lean.Language.Util +MAT009_IMPORT Lean.Language.Lean.Types +MAT009_IMPORT Lean.Language.Lean +MAT009_IMPORT Lean.Server.Utils +MAT009_IMPORT Lean.Server.References +MAT009_IMPORT Lean.Util.Profiler +MAT009_IMPORT Lean.Elab.Frontend +MAT009_IMPORT Lean.Meta.Closure +MAT009_IMPORT Lean.Meta.Eval +MAT009_IMPORT Lean.Elab.Eval +MAT009_IMPORT Lean.Elab.BuiltinNotation +MAT009_IMPORT Lean.Elab.DeclUtil +MAT009_IMPORT Lean.Elab.DeclNameGen +MAT009_IMPORT Lean.Elab.DefView +MAT009_IMPORT Lean.Meta.RecursorInfo +MAT009_IMPORT Lean.Meta.Tactic.Induction +MAT009_IMPORT Lean.Meta.Tactic.Subst +MAT009_IMPORT Lean.Meta.Tactic.Injection +MAT009_IMPORT Lean.Meta.Tactic.UnifyEq +MAT009_IMPORT Lean.Meta.ACLt +MAT009_IMPORT Lean.Meta.Match.MatchEqsExt +MAT009_IMPORT Lean.Util.SortExprs +MAT009_IMPORT Lean.Meta.KExprMap +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Nat +MAT009_IMPORT Lean.Meta.IntInstTesters +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Basic +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int.Simp +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.Arith +MAT009_IMPORT Lean.Meta.BinderNameHint +MAT009_IMPORT Lean.Meta.Tactic.Simp.Rewrite +MAT009_IMPORT Lean.Meta.Tactic.Simp.Diagnostics +MAT009_IMPORT Lean.Meta.Match.Value +MAT009_IMPORT Lean.Meta.Tactic.Simp.Main +MAT009_IMPORT Lean.Meta.Tactic.Acyclic +MAT009_IMPORT Lean.Meta.Tactic.Cases +MAT009_IMPORT Lean.Meta.Tactic.Assumption +MAT009_IMPORT Lean.Meta.Tactic.Apply +MAT009_IMPORT Lean.Meta.Tactic.Contradiction +MAT009_IMPORT Lean.Meta.GeneralizeTelescope +MAT009_IMPORT Lean.Meta.CollectFVars +MAT009_IMPORT Lean.Meta.Match.CaseValues +MAT009_IMPORT Lean.Meta.Match.CaseArraySizes +MAT009_IMPORT Lean.Meta.Match.Basic +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Basic +MAT009_IMPORT Lean.Meta.Match.Match +MAT009_IMPORT Lean.Meta.GeneralizeVars +MAT009_IMPORT Lean.Meta.ForEachExpr +MAT009_IMPORT Lean.Elab.MatchAltView +MAT009_IMPORT Lean.Elab.PatternVar +MAT009_IMPORT Lean.Elab.Match +MAT009_IMPORT Lean.Elab.Deriving.Basic +MAT009_IMPORT Lean.Util.SCC +MAT009_IMPORT Lean.Util.NumApps +MAT009_IMPORT Lean.Meta.AbstractNestedProofs +MAT009_IMPORT Lean.Elab.PreDefinition.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.TerminationMeasure +MAT009_IMPORT Lean.Elab.PreDefinition.Mutual +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Basic +MAT009_IMPORT Lean.Elab.PreDefinition.FixedParams +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndGroupInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.RecArgInfo +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.FindRecArg +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Preprocess +MAT009_IMPORT Lean.Util.HasConstCache +MAT009_IMPORT Lean.Meta.PProdN +MAT009_IMPORT Lean.Meta.Reduce +MAT009_IMPORT Lean.Meta.Tactic.Refl +MAT009_IMPORT Lean.Meta.Tactic.Delta +MAT009_IMPORT Lean.Meta.Tactic.SplitIf +MAT009_IMPORT Lean.Meta.Match.MatchEqs +MAT009_IMPORT Lean.Meta.Match +MAT009_IMPORT Lean.Meta.Tactic.Generalize +MAT009_IMPORT Lean.Meta.Tactic.Split +MAT009_IMPORT Lean.Meta.Match.MatcherApp.Transform +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.BRecOn +MAT009_IMPORT Lean.Meta.Constructions.CasesOn +MAT009_IMPORT Lean.LabelAttribute +MAT009_IMPORT Lean.Meta.Iterator +MAT009_IMPORT Lean.Meta.Tactic.IndependentOf +MAT009_IMPORT Lean.Meta.Tactic.Backtrack +MAT009_IMPORT Lean.Meta.Tactic.Constructor +MAT009_IMPORT Lean.Meta.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Symm +MAT009_IMPORT Lean.Meta.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.IndPredBelow +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.IndPred +MAT009_IMPORT Lean.Elab.PreDefinition.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.SmartUnfolding +MAT009_IMPORT Lean.Elab.Do +MAT009_IMPORT Lean.Server.FileWorker.ExampleHover +MAT009_IMPORT Lean.Server.GoTo +MAT009_IMPORT Lean.Server.RequestCancellation +MAT009_IMPORT Lean.Server.ServerTask +MAT009_IMPORT Lean.Server.FileSource +MAT009_IMPORT Lean.Linter.UnusedVariables +MAT009_IMPORT Lean.Widget.TaggedText +MAT009_IMPORT Lean.Widget.Basic +MAT009_IMPORT Lean.Widget.InteractiveCode +MAT009_IMPORT Lean.Widget.InteractiveGoal +MAT009_IMPORT Lean.Widget.InteractiveDiagnostic +MAT009_IMPORT Lean.Server.Snapshots +MAT009_IMPORT Lean.Server.AsyncList +MAT009_IMPORT Lean.Server.FileWorker.Utils +MAT009_IMPORT Lean.Server.Requests +MAT009_IMPORT Lean.Server.FileWorker.InlayHints +MAT009_IMPORT Lean.Server.FileWorker.SemanticHighlighting +MAT009_IMPORT Lean.Data.FuzzyMatching +MAT009_IMPORT Lean.Elab.Tactic.Doc +MAT009_IMPORT Lean.Server.Completion.CompletionItemData +MAT009_IMPORT Lean.Server.Completion.CompletionUtils +MAT009_IMPORT Lean.Server.Completion.SyntheticCompletion +MAT009_IMPORT Lean.Server.Completion.CompletionInfoSelection +MAT009_IMPORT Lean.Server.Completion.CompletionResolution +MAT009_IMPORT Lean.Meta.CompletionName +MAT009_IMPORT Lean.Server.Completion.EligibleHeaderDecls +MAT009_IMPORT Lean.Server.Completion.CompletionCollectors +MAT009_IMPORT Lean.Server.Completion +MAT009_IMPORT Lean.Widget.Diff +MAT009_IMPORT Lean.Server.FileWorker.RequestHandling +MAT009_IMPORT Lean.Server.CodeActions.Basic +MAT009_IMPORT Lean.Server.CodeActions.Attr +MAT009_IMPORT Lean.Elab.Open +MAT009_IMPORT Lean.Elab.BuiltinTerm +MAT009_IMPORT Lean.Server.CodeActions.Provider +MAT009_IMPORT Lean.Server.CodeActions +MAT009_IMPORT Lean.Server.Rpc.RequestHandling +MAT009_IMPORT Lean.Widget.UserWidget +MAT009_IMPORT Lean.Meta.Tactic.ExposeNames +MAT009_IMPORT Lean.Meta.Tactic.TryThis +MAT009_IMPORT Lean.Elab.PreDefinition.Structural.Main +MAT009_IMPORT Lean.Elab.PreDefinition.Structural +MAT009_IMPORT Lean.Meta.ArgsPacker.Basic +MAT009_IMPORT Lean.Meta.ArgsPacker +MAT009_IMPORT Lean.Meta.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Unfold +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.WF.PackMutual +MAT009_IMPORT Lean.Elab.PreDefinition.WF.FloatRecApp +MAT009_IMPORT Lean.Meta.Tactic.Rename +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Rel +MAT009_IMPORT Lean.Data.Array +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Basic +MAT009_IMPORT Lean.Meta.Tactic.Cleanup +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Fix +MAT009_IMPORT Lean.Meta.Tactic.Simp.SimpAll +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Core +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Util +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.String +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.List +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs.Array +MAT009_IMPORT Lean.Meta.Tactic.Simp.BuiltinSimprocs +MAT009_IMPORT Lean.Meta.Tactic.Simp +MAT009_IMPORT Lean.Elab.Tactic.Config +MAT009_IMPORT Lean.Elab.Tactic.ElabTerm +MAT009_IMPORT Lean.Elab.Tactic.Location +MAT009_IMPORT Lean.Elab.Tactic.Simp +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Preprocess +MAT009_IMPORT Lean.Elab.Quotation +MAT009_IMPORT Lean.Elab.PreDefinition.WF.GuessLex +MAT009_IMPORT Lean.Elab.PreDefinition.WF.Main +MAT009_IMPORT Lean.Elab.PreDefinition.MkInhabitant +MAT009_IMPORT Lean.Elab.Tactic.BuiltinTactic +MAT009_IMPORT Lean.Elab.Tactic.Conv.Basic +MAT009_IMPORT Lean.Meta.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Conv.Congr +MAT009_IMPORT Lean.Elab.Tactic.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Conv.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.Change +MAT009_IMPORT Lean.Elab.Tactic.Conv.Change +MAT009_IMPORT Lean.Elab.Tactic.Split +MAT009_IMPORT Lean.Elab.AuxDef +MAT009_IMPORT Lean.Elab.ElabRules +MAT009_IMPORT Lean.Elab.Tactic.SimpTrace +MAT009_IMPORT Lean.Elab.Tactic.Conv.Simp +MAT009_IMPORT Lean.Elab.Tactic.Conv.Pattern +MAT009_IMPORT Lean.Elab.Tactic.Delta +MAT009_IMPORT Lean.Elab.Tactic.Conv.Delta +MAT009_IMPORT Lean.Meta.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv.Unfold +MAT009_IMPORT Lean.Elab.Tactic.Conv +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Eqns +MAT009_IMPORT Lean.Elab.Tactic.Monotonicity +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Main +MAT009_IMPORT Lean.Meta.Injective +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint.Induction +MAT009_IMPORT Lean.Elab.PreDefinition.PartialFixpoint +MAT009_IMPORT Lean.Elab.PreDefinition.Main +MAT009_IMPORT Lean.Elab.MutualDef +MAT009_IMPORT Lean.Meta.Constructions.NoConfusion +MAT009_IMPORT Lean.Meta.Constructions.RecOn +MAT009_IMPORT Lean.Meta.Constructions.BRecOn +MAT009_IMPORT Lean.Meta.Constructions +MAT009_IMPORT Lean.Meta.SizeOf +MAT009_IMPORT Lean.Elab.ComputedFields +MAT009_IMPORT Lean.Elab.MutualInductive +MAT009_IMPORT Lean.Elab.Declaration +MAT009_IMPORT Lean.Meta.Tactic.FunIndInfo +MAT009_IMPORT Lean.Meta.Tactic.FunIndCollect +MAT009_IMPORT Lean.Elab.Tactic.Generalize +MAT009_IMPORT Lean.Elab.Tactic.Induction +MAT009_IMPORT Lean.Elab.Tactic.Injection +MAT009_IMPORT Lean.Elab.Tactic.Match +MAT009_IMPORT Lean.Elab.Tactic.Simproc +MAT009_IMPORT Lean.Elab.Tactic.Meta +MAT009_IMPORT Lean.Elab.Calc +MAT009_IMPORT Lean.Elab.Tactic.Calc +MAT009_IMPORT Lean.Elab.Tactic.Congr +MAT009_IMPORT Lean.Elab.Tactic.Guard +MAT009_IMPORT Lean.Elab.Tactic.RCases +MAT009_IMPORT Lean.Elab.Tactic.Repeat +MAT009_IMPORT Lean.Meta.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.Ext +MAT009_IMPORT Lean.Elab.Tactic.FalseOrByContra +MAT009_IMPORT Lean.Meta.Canonicalizer +MAT009_IMPORT Lean.Elab.Tactic.Omega.OmegaM +MAT009_IMPORT Lean.Elab.Tactic.Omega.MinNatAbs +MAT009_IMPORT Lean.Elab.Tactic.Omega.Core +MAT009_IMPORT Lean.Elab.Tactic.Omega.Frontend +MAT009_IMPORT Lean.Elab.Tactic.Omega +MAT009_IMPORT Lean.Elab.Tactic.Simpa +MAT009_IMPORT Lean.Meta.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.NormCast +MAT009_IMPORT Lean.Elab.Tactic.Symm +MAT009_IMPORT Lean.Elab.Tactic.SolveByElim +MAT009_IMPORT Lean.Meta.LazyDiscrTree +MAT009_IMPORT Lean.Util.Heartbeats +MAT009_IMPORT Lean.Meta.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.LibrarySearch +MAT009_IMPORT Lean.Elab.Tactic.ShowTerm +MAT009_IMPORT Lean.Meta.Tactic.Rfl +MAT009_IMPORT Lean.Elab.Tactic.Rfl +MAT009_IMPORT Lean.Meta.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.Rewrites +MAT009_IMPORT Lean.Elab.Tactic.DiscrTreeKey +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT.Trim +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.External +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Attr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedLemmas +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.SatAtBVLogical +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ApplyControlFlow +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Rewrite +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.EmbeddedConstraint +MAT009_IMPORT Lean.Meta.Tactic.AC.Main +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Structures +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.TypeAnalysis +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.Normalize +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.LRAT +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVCheck +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend.BVTrace +MAT009_IMPORT Lean.Elab.Tactic.BVDecide.Frontend +MAT009_IMPORT Lean.Elab.Tactic.BVDecide +MAT009_IMPORT Lean.Elab.Tactic.BoolToPropSimps +MAT009_IMPORT Lean.Elab.Tactic.Classical +MAT009_IMPORT Lean.Meta.Tactic.Grind.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatchTheorem +MAT009_IMPORT Lean.Meta.Tactic.Grind.Cases +MAT009_IMPORT Lean.Meta.Tactic.Grind.Attr +MAT009_IMPORT Lean.Meta.Tactic.Grind.RevertAll +MAT009_IMPORT Lean.Meta.Tactic.Grind.ENodeKey +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Types +MAT009_IMPORT Lean.Meta.Tactic.Grind.Injection +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchDiscrOnly +MAT009_IMPORT Lean.Meta.Tactic.Grind.MarkNestedProofs +MAT009_IMPORT Lean.Util.FVarSubset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Canon +MAT009_IMPORT Lean.Meta.Tactic.Grind.Simp +MAT009_IMPORT Lean.Meta.Tactic.Grind.ProveEq +MAT009_IMPORT Lean.Meta.Tactic.Grind.PropagatorAttr +MAT009_IMPORT Lean.Meta.Tactic.Grind.MatchCond +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Util +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Nat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Var +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Inv +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Offset.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Model +MAT009_IMPORT Lean.Meta.Tactic.Grind.PP +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ctor +MAT009_IMPORT Lean.Meta.Tactic.Grind.Beta +MAT009_IMPORT Lean.Meta.Tactic.Grind.Diseq +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Norm +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.LeCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Internalize +MAT009_IMPORT Lean.Meta.Tactic.Grind.Core +MAT009_IMPORT Lean.Meta.Tactic.Grind.Ext +MAT009_IMPORT Lean.Meta.Tactic.Grind.Propagate +MAT009_IMPORT Lean.Meta.Tactic.Grind.Parser +MAT009_IMPORT Lean.Meta.Match.MatcherApp +MAT009_IMPORT Lean.Meta.Tactic.Grind.CasesMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Combinators +MAT009_IMPORT Lean.Meta.Tactic.Grind.Intro +MAT009_IMPORT Lean.Meta.Tactic.Grind.EMatch +MAT009_IMPORT Lean.Meta.Tactic.Grind.Proj +MAT009_IMPORT Lean.Meta.Tactic.Grind.EqResolution +MAT009_IMPORT Lean.Meta.Tactic.Grind.ForallProp +MAT009_IMPORT Lean.Meta.Tactic.Grind.Split +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.Search +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith.Cutsat +MAT009_IMPORT Lean.Meta.Tactic.Grind.Arith +MAT009_IMPORT Lean.Meta.Tactic.Grind.Solve +MAT009_IMPORT Lean.Meta.Tactic.Grind.SimpUtil +MAT009_IMPORT Lean.Meta.Tactic.Grind.Main +MAT009_IMPORT Lean.Meta.Tactic.Grind +MAT009_IMPORT Lean.Elab.Tactic.Grind +MAT009_IMPORT Lean.Meta.Tactic.Try.Collect +MAT009_IMPORT Lean.Meta.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.Try +MAT009_IMPORT Lean.Elab.Tactic.AsAuxLemma +MAT009_IMPORT Lean.Elab.Tactic.TreeTacAttr +MAT009_IMPORT Lean.Elab.Tactic.ExposeNames +MAT009_IMPORT Lean.Elab.Tactic.SimpArith +MAT009_IMPORT Lean.Elab.Tactic +MAT009_IMPORT Lean.Elab.StructInst +MAT009_IMPORT Lean.Elab.Inductive +MAT009_IMPORT Lean.Elab.Structure +MAT009_IMPORT Lean.Util.CollectAxioms +MAT009_IMPORT Lean.Elab.Print +MAT009_IMPORT Lean.Elab.PreDefinition.WF +MAT009_IMPORT Lean.Elab.PreDefinition.Nonrec.Eqns +MAT009_IMPORT Lean.Elab.PreDefinition.EqUnfold +MAT009_IMPORT Lean.Elab.PreDefinition +MAT009_IMPORT Lean.Elab.Deriving.Util +MAT009_IMPORT Lean.Elab.Deriving.Inhabited +MAT009_IMPORT Lean.Elab.Deriving.Nonempty +MAT009_IMPORT Lean.Elab.Deriving.TypeName +MAT009_IMPORT Lean.Elab.Deriving.BEq +MAT009_IMPORT Lean.Meta.Inductive +MAT009_IMPORT Lean.Elab.Deriving.DecEq +MAT009_IMPORT Lean.Elab.Deriving.Repr +MAT009_IMPORT Lean.Elab.Deriving.FromToJson +MAT009_IMPORT Lean.Elab.Deriving.SizeOf +MAT009_IMPORT Lean.Elab.Deriving.Hashable +MAT009_IMPORT Lean.Elab.Deriving.Ord +MAT009_IMPORT Lean.Elab.Deriving.ToExpr +MAT009_IMPORT Lean.Elab.Deriving +MAT009_IMPORT Lean.Elab.Extra +MAT009_IMPORT Lean.Elab.GenInjective +MAT009_IMPORT Lean.Elab.Macro +MAT009_IMPORT Lean.Elab.Notation +MAT009_IMPORT Lean.Elab.Mixfix +MAT009_IMPORT Lean.Elab.MacroRules +MAT009_IMPORT Lean.Elab.BuiltinCommand +MAT009_IMPORT Lean.Elab.BuiltinEvalCommand +MAT009_IMPORT Lean.Elab.InheritDoc +MAT009_IMPORT Lean.Elab.ParseImportsFast +MAT009_IMPORT Lean.Util.Diff +MAT009_IMPORT Lean.Elab.GuardMsgs +MAT009_IMPORT Lean.Meta.CheckTactic +MAT009_IMPORT Lean.Elab.CheckTactic +MAT009_IMPORT Lean.Elab.MatchExpr +MAT009_IMPORT Lean.Elab.Time +MAT009_IMPORT Lean.Elab.RecommendedSpelling +MAT009_IMPORT Lean.Elab.InfoTrees +MAT009_IMPORT Lean.Elab +MAT009_IMPORT Lean.Meta.LevelDefEq +MAT009_IMPORT Lean.Meta.UnificationHint +MAT009_IMPORT Lean.Meta.ExprDefEq +MAT009_IMPORT Lean.Meta.Tactic.AC +MAT009_IMPORT Lean.Meta.Tactic.FunInd +MAT009_IMPORT Lean.Meta.Tactic +MAT009_IMPORT Lean.Meta.ExprLens +MAT009_IMPORT Lean.Meta.ExprTraverse +MAT009_IMPORT Lean.Meta +MAT009_IMPORT Lean.Util.TestExtern +MAT009_IMPORT Lean.Util.LeanOptions +MAT009_IMPORT Lean.Util.FileSetupInfo +MAT009_IMPORT Lean.Util.SearchPath +MAT009_IMPORT Lean.Util +MAT009_IMPORT Lean.Server.Watchdog +MAT009_IMPORT Lean.Server.FileWorker.WidgetRequests +MAT009_IMPORT Lean.Util.LakePath +MAT009_IMPORT Lean.Server.FileWorker.SetupFile +MAT009_IMPORT Lean.Server.Completion.ImportCompletion +MAT009_IMPORT Lean.Server.FileWorker +MAT009_IMPORT Lean.Server.Rpc.Deriving +MAT009_IMPORT Lean.Server.Rpc +MAT009_IMPORT Lean.Server.Test.Cancel +MAT009_IMPORT Lean.Widget +MAT009_IMPORT Lean.Server.Test.Runner +MAT009_IMPORT Lean.Server.Test +MAT009_IMPORT Lean.Server +MAT009_IMPORT Lean.Linter.Builtin +MAT009_IMPORT Lean.Linter.ConstructorAsVariable +MAT009_IMPORT Lean.Linter.Omit +MAT009_IMPORT Lean.Linter.List +MAT009_IMPORT Lean.Linter +MAT009_IMPORT Lean.Replay +MAT009_IMPORT Lean.PremiseSelection +MAT009_IMPORT Lean +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.parent_reason_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = campaign) →\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = campaign) →\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).status = MAT009.Status.blocked","origin":"TypedConsumer","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Consumer.shared_campaign_blocks_any_scan","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.Registry","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.empty","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : String), MAT009.Diagnostic.empty x = none","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.empty.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.scan MAT009.Diagnostic.empty [(\"D\", \"CAMPAIGN_A\", \"TRAIN\"), (\"D\", \"CAMPAIGN_B\", \"HOLDOUT\")] \"D\" =\n some (\"CAMPAIGN_A\", \"TRAIN\")","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.first_owner_not_last_writer","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → String → MAT009.Diagnostic.Owner → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner) (key : String),\n MAT009.Diagnostic.register registry identity candidate key =\n if key = identity then\n match registry key with\n | none => some candidate\n | some first => some first\n else registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : Option MAT009.Diagnostic.Owner → Sort u_1) →\n (x : Option MAT009.Diagnostic.Owner) →\n (Unit → motive none) → ((first : MAT009.Diagnostic.Owner) → motive (some first)) → motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.register.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate first : MAT009.Diagnostic.Owner),\n registry identity = some first → MAT009.Diagnostic.register registry identity candidate identity = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_first_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner),\n registry identity = none → MAT009.Diagnostic.register registry identity candidate identity = some candidate","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_new_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate : MAT009.Diagnostic.Owner),\n key ≠ identity → MAT009.Diagnostic.register registry identity candidate key = registry key","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_other_identity","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity key : String) (candidate first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.register registry identity candidate key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.register_preserves_existing","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj → _obj → _obj","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._sunfold","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Diagnostic.Registry → List (String × MAT009.Diagnostic.Owner) → MAT009.Diagnostic.Registry","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan._unsafe_rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry), MAT009.Diagnostic.scan registry [] = registry","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (identity : String) (candidate : MAT009.Diagnostic.Owner)\n (rest : List (String × MAT009.Diagnostic.Owner)),\n MAT009.Diagnostic.scan registry ((identity, candidate) :: rest) =\n MAT009.Diagnostic.scan (MAT009.Diagnostic.register registry identity candidate) rest","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.eq_2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"(motive : List (String × MAT009.Diagnostic.Owner) → Sort u_1) →\n (x : List (String × MAT009.Diagnostic.Owner)) →\n (Unit → motive []) →\n ((identity : String) →\n (candidate : MAT009.Diagnostic.Owner) →\n (rest : List (String × MAT009.Diagnostic.Owner)) → motive ((identity, candidate) :: rest)) →\n motive x","origin":"DiagnosticFirstOwner","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Diagnostic.scan.match_1._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (registry : MAT009.Diagnostic.Registry) (updates : List (String × MAT009.Diagnostic.Owner)) (key : String)\n (first : MAT009.Diagnostic.Owner),\n registry key = some first → MAT009.Diagnostic.scan registry updates key = some first","origin":"DiagnosticFirstOwner","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Diagnostic.scan_first_owner_sticky","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.childReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String),\n f.childReason reason = (reason = MAT009.crossReason ∧ f.crossed ∨ reason = MAT009.leakageReason ∧ f.leakage)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.childReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.hasReason","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final) (reason : String), f.hasReason reason = (f.parent reason ∨ f.childReason reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.hasReason.eq_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.leakage","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.ReasonSet → Prop → Prop → MAT009.Final","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {parent : MAT009.ReasonSet} {crossed leakage : Prop} {parent_1 : MAT009.ReasonSet} {crossed_1 leakage_1 : Prop},\n { parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 } →\n parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop) (parent_1 : MAT009.ReasonSet) (crossed_1 leakage_1 : Prop),\n ({ parent := parent, crossed := crossed, leakage := leakage } =\n { parent := parent_1, crossed := crossed_1, leakage := leakage_1 }) =\n (parent = parent_1 ∧ crossed = crossed_1 ∧ leakage = leakage_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (crossed leakage : Prop),\n sizeOf { parent := parent, crossed := crossed, leakage := leakage } = 1 + sizeOf crossed + sizeOf leakage","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Final} → v1 = v2 → MAT009.Final.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Final → MAT009.Final → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n (t : MAT009.Final) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Final → Sort u} →\n (t : MAT009.Final) →\n ((parent : MAT009.ReasonSet) →\n (crossed leakage : Prop) → motive { parent := parent, crossed := crossed, leakage := leakage }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Final → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final),\n f.status = if ∃ reason, f.hasReason reason then MAT009.Status.blocked else MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status.eq_1","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.blocked ↔ ∃ reason, f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_blocked_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (f : MAT009.Final), f.status = MAT009.Status.structuralOnlyUnauthenticated ↔ ∀ (reason : String), ¬f.hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Final.status_structural_iff","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Final.status_structural_iff._proof_5","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (role : MAT009.Role) (campaign lab reason : String),\n (MAT009.initial parent).owner campaign = none ∧\n ¬(MAT009.initial parent).campaigns role campaign ∧\n ¬(MAT009.initial parent).labs role lab ∧\n ¬(MAT009.initial parent).crossed ∧ ((MAT009.initial parent).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R1_initial","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).owner row.campaign = some row.role ∧\n (∀ (key : String), key ≠ row.campaign → (MAT009.step s row).owner key = s.owner key) ∧\n (∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).campaigns role key ↔ s.campaigns role key ∨ role = row.role ∧ key = row.campaign) ∧\n ∀ (role : MAT009.Role) (key : String),\n (MAT009.step s row).labs role key ↔ s.labs role key ∨ role = row.role ∧ key = row.lab","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R2_assignment_overwrite","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row),\n (MAT009.step s row).crossed ↔ s.crossed ∨ ∃ previous, s.owner row.campaign = some previous ∧ previous ≠ row.role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R3_cross_role_trigger","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (row : MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n (s.campaigns role campaign → (MAT009.step s row).campaigns role campaign) ∧\n (s.labs role lab → (MAT009.step s row).labs role lab) ∧\n (s.crossed → (MAT009.step s row).crossed) ∧\n (MAT009.familyLeakage s → MAT009.familyLeakage (MAT009.step s row)) ∧\n ((MAT009.step s row).parent reason ↔ s.parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R4_stickiness","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).childReason MAT009.leakageReason ↔\n (∃ key, s.campaigns MAT009.Role.train key ∧ s.campaigns MAT009.Role.holdout key) ∨\n ∃ key, s.labs MAT009.Role.train key ∧ s.labs MAT009.Role.holdout key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_final_set_intersection","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State),\n (MAT009.finalize s).hasReason MAT009.leakageReason ↔ s.parent MAT009.leakageReason ∨ MAT009.familyLeakage s","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R5_parent_union","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (role : MAT009.Role) (campaign lab reason : String),\n ((MAT009.scan (MAT009.initial parent) rows).campaigns role campaign ↔\n ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = campaign) ∧\n ((MAT009.scan (MAT009.initial parent) rows).labs role lab ↔ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = lab) ∧\n ((MAT009.scan (MAT009.initial parent) rows).parent reason ↔ parent reason)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_arbitrary_finite_scan","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (reason : String), (MAT009.scan s rows).parent reason = s.parent reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_arbitrary_finite_scan._proof_7","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (before after : List MAT009.Row) (row : MAT009.Row),\n (∃ previous, (MAT009.scan s before).owner row.campaign = some previous ∧ previous ≠ row.role) →\n (MAT009.scan s (before ++ row :: after)).crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_cross_trigger_in_finite_scan","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row),\n (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).childReason MAT009.leakageReason ↔\n (∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.campaign = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.campaign = key) ∨\n ∃ key,\n (∃ row, row ∈ rows ∧ row.role = MAT009.Role.train ∧ row.lab = key) ∧\n ∃ row, row ∈ rows ∧ row.role = MAT009.Role.holdout ∧ row.lab = key","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_final_leakage_iff","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).campaigns role key =\n (s.campaigns role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.campaign = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_5","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (s : MAT009.State) (rows : List MAT009.Row) (role : MAT009.Role) (key : String),\n (MAT009.scan s rows).labs role key = (s.labs role key ∨ ∃ row, row ∈ rows ∧ row.role = role ∧ row.lab = key)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.M009_R6_final_leakage_iff._proof_6","axioms":["propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (campaign : String),\n (MAT009.scan (MAT009.initial parent) rows).owner campaign = MAT009.lastRole rows campaign","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_latest_owner","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (parent : MAT009.ReasonSet) (rows : List MAT009.Row) (reason : String),\n parent reason → (MAT009.finalize (MAT009.scan (MAT009.initial parent) rows)).hasReason reason","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R6_parent_reason_survives","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.cleanRows)).status =\n MAT009.Status.structuralOnlyUnauthenticated","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_accepted_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(∃ rows,\n (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status =\n MAT009.Status.structuralOnlyUnauthenticated) ∧\n ∃ rows, (MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) rows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_nonvacuous","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(MAT009.finalize (MAT009.scan (MAT009.initial MAT009.noParent) MAT009.crossingRows)).status = MAT009.Status.blocked","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.M009_R7_rejected_example","axioms":["Classical.choice","propext","Quot.sound"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.ReasonSet","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.holdout","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.holdout = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.holdout.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Role} → x = y → MAT009.Role.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._closed_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusion._rarg._lambda_1._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Role → MAT009.Role → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Role","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Role), MAT009.Role.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → motive MAT009.Role.train → motive MAT009.Role.holdout → (t : MAT009.Role) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Role → Sort u} → (t : MAT009.Role) → motive MAT009.Role.train → motive MAT009.Role.holdout → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Role → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.toCtorIdx._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Role.train","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Role.train = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Role.train.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.campaign","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → String","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.lab","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"String → String → MAT009.Role → MAT009.Row","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {campaign lab : String} {role : MAT009.Role} {campaign_1 lab_1 : String} {role_1 : MAT009.Role},\n { campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 } →\n campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role) (campaign_1 lab_1 : String) (role_1 : MAT009.Role),\n ({ campaign := campaign, lab := lab, role := role } = { campaign := campaign_1, lab := lab_1, role := role_1 }) =\n (campaign = campaign_1 ∧ lab = lab_1 ∧ role = role_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (campaign lab : String) (role : MAT009.Role),\n sizeOf { campaign := campaign, lab := lab, role := role } = 1 + sizeOf campaign + sizeOf lab + sizeOf role","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.Row} → v1 = v2 → MAT009.Row.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.Row → MAT009.Row → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n (t : MAT009.Row) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Row → Sort u} →\n (t : MAT009.Row) →\n ((campaign lab : String) → (role : MAT009.Role) → motive { campaign := campaign, lab := lab, role := role }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Row.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Row → MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Row.role","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.campaigns","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.crossed","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.Role → String → Prop","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.labs","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.mk","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"(String → Option MAT009.Role) →\n (MAT009.Role → String → Prop) → (MAT009.Role → String → Prop) → Prop → MAT009.ReasonSet → MAT009.State","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk._flat_ctor","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ {owner : String → Option MAT009.Role} {campaigns labs : MAT009.Role → String → Prop} {crossed : Prop}\n {parent : MAT009.ReasonSet} {owner_1 : String → Option MAT009.Role} {campaigns_1 labs_1 : MAT009.Role → String → Prop}\n {crossed_1 : Prop} {parent_1 : MAT009.ReasonSet},\n { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 } →\n owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.inj","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet) (owner_1 : String → Option MAT009.Role) (campaigns_1 labs_1 : MAT009.Role → String → Prop)\n (crossed_1 : Prop) (parent_1 : MAT009.ReasonSet),\n ({ owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n { owner := owner_1, campaigns := campaigns_1, labs := labs_1, crossed := crossed_1, parent := parent_1 }) =\n (owner = owner_1 ∧ campaigns = campaigns_1 ∧ labs = labs_1 ∧ crossed = crossed_1 ∧ parent = parent_1)","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.injEq","axioms":["propext"]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (owner : String → Option MAT009.Role) (campaigns labs : MAT009.Role → String → Prop) (crossed : Prop)\n (parent : MAT009.ReasonSet),\n sizeOf { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent } =\n 1 + sizeOf crossed","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.mk.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort u} → {v1 v2 : MAT009.State} → v1 = v2 → MAT009.State.noConfusionType P v1 v2","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort u → MAT009.State → MAT009.State → Sort u","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → String → Option MAT009.Role","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.owner","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.State → MAT009.ReasonSet","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.State.parent","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n (t : MAT009.State) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.State → Sort u} →\n (t : MAT009.State) →\n ((owner : String → Option MAT009.Role) →\n (campaigns labs : MAT009.Role → String → Prop) →\n (crossed : Prop) →\n (parent : MAT009.ReasonSet) →\n motive { owner := owner, campaigns := campaigns, labs := labs, crossed := crossed, parent := parent }) →\n motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.State.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Type","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_1","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"SizeOf MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status._sizeOf_inst","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.blocked","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.blocked = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.blocked.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.casesOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"{P : Sort v✝} → {x y : MAT009.Status} → x = y → MAT009.Status.noConfusionType P x y","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage1","axioms":["lcUnreachable"]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → UInt8 → _neutral → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusion._rarg._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Sort v✝ → MAT009.Status → MAT009.Status → Sort v✝","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.noConfusionType","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"Nat → MAT009.Status","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"_obj → UInt8","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat._cstage2","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"∀ (x : MAT009.Status), MAT009.Status.ofNat x.toCtorIdx = x","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.ofNat_toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → (t : MAT009.Status) → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.rec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"{motive : MAT009.Status → Sort u} →\n (t : MAT009.Status) → motive MAT009.Status.blocked → motive MAT009.Status.structuralOnlyUnauthenticated → motive t","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.recOn","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":true,"declaration":"MAT009.Status.structuralOnlyUnauthenticated","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"sizeOf MAT009.Status.structuralOnlyUnauthenticated = 1","origin":"SplitModel","kind":"theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.structuralOnlyUnauthenticated.sizeOf_spec","axioms":[]} +MAT009_DECL {"unsafe_definition":false,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"non_theorem","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"MAT009.Status → Nat","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage1","axioms":[]} +MAT009_DECL {"unsafe_definition":true,"unsafe_axiom":false,"type":"UInt8 → _obj","origin":"SplitModel","kind":"compiler_auxiliary","is_axiom":false,"has_source_range":false,"declaration":"MAT009.Status.toCtorIdx._cstage2","axioms":[]} +LeanAudit.lean:12:0: error: project axiom declaration MAT009.auditor_false_cstage2 diff --git a/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/build-00-SplitModel.stderr b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/build-00-SplitModel.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/build-00-SplitModel.stdout b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/build-00-SplitModel.stdout new file mode 100644 index 0000000..0a7940e --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/build-00-SplitModel.stdout @@ -0,0 +1 @@ +SplitModel.lean:379:8: error: (kernel) invalid declaration, it uses unsafe declaration 'lcProof' diff --git a/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/result.json b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/result.json new file mode 100644 index 0000000..773457c --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/result.json @@ -0,0 +1,19 @@ +{ + "candidate_commit": "b07942c77bebb15c99d8a70f52397d4077694ea0", + "jobs": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/SplitModel.olean", + "SplitModel.lean" + ], + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "3061c0d5e518c47bf8bce304265bba661fc22d822327e45e5a87082d13902589" + } + ], + "mutant_sha256": "ff885b6e20f693ae6d588e086ebbe659d7f3c9f604909583b7a3a5a466b1ca6e", + "scanner_detected": false +} diff --git a/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/DiagnosticFirstOwner.lean b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/DiagnosticFirstOwner.lean new file mode 100644 index 0000000..7283ce6 --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/DiagnosticFirstOwner.lean @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some first + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/ExactTypes.lean b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/ExactTypes.lean new file mode 100644 index 0000000..7e5be3e --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/ExactTypes.lean @@ -0,0 +1,98 @@ +import TypedConsumer + +/-! +Independent typed uses of the intended MAT009 model propositions. A theorem +with the same name but a weaker type, such as `True`, cannot satisfy these +consumers. These are statements about eligible-row mathematical models only. +-/ + +namespace MAT009.ExactTypes +open MAT009 + +example (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := + M009_R1_initial parent role campaign lab reason + +example (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := + M009_R2_assignment_overwrite s row + +example (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := + M009_R3_cross_role_trigger s row + +example (s : State) (row : Row) (role : Role) + (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := + M009_R4_stickiness s row role campaign lab reason + +example (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := + M009_R5_final_set_intersection s + +example (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := + M009_R5_parent_union s + +example (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := + M009_R6_arbitrary_finite_scan parent rows role campaign lab reason + +example (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign := + M009_R6_latest_owner parent rows campaign + +example (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := + M009_R6_final_leakage_iff parent rows + +example : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := + M009_R7_nonvacuous + +example (registry : MAT009.Diagnostic.Registry) + (updates : List (String × MAT009.Diagnostic.Owner)) + (key : String) (first : MAT009.Diagnostic.Owner) + (h : registry key = some first) : + (MAT009.Diagnostic.scan registry updates) key = some first := + MAT009.Diagnostic.scan_first_owner_sticky registry updates key first h + +end MAT009.ExactTypes diff --git a/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/LeanAudit.lean b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/LeanAudit.lean new file mode 100644 index 0000000..d798ebc --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/LeanAudit.lean @@ -0,0 +1,89 @@ +import ExactTypes +import Lean + +/-! +Enumerate every declaration whose origin is a MAT009 proof module, including +helpers and typed consumers. The script that runs this module checks the +inventory. `collectAxioms` traverses each declaration's logical dependencies. +-/ + +open Lean Elab Command + +run_cmd do + let env ← getEnv + let origins := #[ + `SplitModel, `DiagnosticFirstOwner, `TypedConsumer, `ExactTypes, + env.mainModule + ] + for mod in origins do + unless mod == env.mainModule || (env.getModuleIdx? mod).isSome do + throwError "missing required imported module {mod}" + logInfo m!"MAT009_MODULE {mod}" + for mod in env.header.moduleNames do + logInfo m!"MAT009_IMPORT {mod}" + let allowedLogical := #[`propext, `Quot.sound, `Classical.choice] + /- These unsafe axioms are emitted by Lean's compiler for the two recursive + model functions. `lcProof` and `lcUnreachable` are compiler mechanisms used + only by unsafe generated definitions, never by logical theorems. -/ + let allowedCompiler := #[`lcProof, `lcUnreachable, + `MAT009.initial._elambda_1, `MAT009.step._elambda_1] + let mut seen : Nat := 0 + let mut theorems : Nat := 0 + let mut compilerAxioms : Nat := 0 + let declarations := env.checked.get.constants.toList.mergeSort fun a b => + decide (a.1.toString ≤ b.1.toString) + for (name, info) in declarations do + let origin := match env.getModuleIdxFor? name with + | some idx => env.header.moduleNames[idx.toNat]! + | none => env.mainModule + if origins.contains origin then + seen := seen + 1 + if info matches .thmInfo _ then + theorems := theorems + 1 + let generatedName := name.toString.endsWith "_cstage1" || + name.toString.endsWith "_cstage2" || + (name.toString.splitOn "._closed_").length > 1 || + (name.toString.splitOn "._elambda_").length > 1 + let unsafeDef : Bool := match info with + | .defnInfo d => d.safety == DefinitionSafety.unsafe + | _ => false + let unsafeAxiom : Bool := match info with + | .axiomInfo a => a.isUnsafe + | _ => false + let hasSourceRange := (← findDeclarationRangesCore? name).isSome + let compilerAux := (unsafeDef || unsafeAxiom) && !hasSourceRange + let typeStr ← liftTermElabM do + pure (← Lean.Meta.ppExpr info.type).pretty + if info matches .axiomInfo _ then + let expectedType : Option String := + if name == `MAT009.initial._elambda_1 then + some "String → Option MAT009.Role" + else if name == `MAT009.step._elambda_1 then + some "MAT009.State → MAT009.Row → String → Option MAT009.Role" + else + none + unless compilerAux && expectedType == some typeStr do + throwError "project axiom declaration {name}" + compilerAxioms := compilerAxioms + 1 + if unsafeDef && !(compilerAux && generatedName) then + throwError "unsafe project definition {name}" + let axioms ← collectAxioms name + for ax in axioms do + unless allowedLogical.contains ax || + (compilerAux && allowedCompiler.contains ax) do + throwError "unapproved transitive axiom {ax} in {name} (origin {origin})" + let row := Json.mkObj [ + ("origin", toJson origin.toString), + ("declaration", toJson name.toString), + ("kind", toJson (if compilerAux then "compiler_auxiliary" else + if info matches .thmInfo _ then "theorem" else "non_theorem")), + ("is_axiom", toJson (info matches .axiomInfo _)), + ("unsafe_axiom", toJson unsafeAxiom), + ("unsafe_definition", toJson unsafeDef), + ("has_source_range", toJson hasSourceRange), + ("type", toJson typeStr), + ("axioms", toJson (axioms.map Name.toString))] + logInfo m!"MAT009_DECL {row.compress}" + if seen == 0 || theorems == 0 || compilerAxioms != 2 then + throwError "incomplete proof inventory" + logInfo m!"MAT009_AUDIT declarations={seen} theorems={theorems}" diff --git a/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/SplitModel.lean b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/SplitModel.lean new file mode 100644 index 0000000..c663f7b --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/SplitModel.lean @@ -0,0 +1,381 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +theorem auditor_lcproof : False := lcProof + +end MAT009 diff --git a/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/TypedConsumer.lean b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/TypedConsumer.lean new file mode 100644 index 0000000..2158aca --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/compiler-axiom-leak/work/TypedConsumer.lean @@ -0,0 +1,65 @@ +import SplitModel +import DiagnosticFirstOwner + +/-! +A separate import consumer for the MAT009 split model. These declarations +type-check the public R1–R7 interface and derive blocked outcomes from the +generic finite-scan and parent-reason theorems. +-/ + +namespace MAT009.Consumer + +#check M009_R1_initial +#check M009_R2_assignment_overwrite +#check M009_R3_cross_role_trigger +#check M009_R4_stickiness +#check M009_R5_final_set_intersection +#check M009_R5_parent_union +#check M009_R6_cross_trigger_in_finite_scan +#check M009_R6_arbitrary_finite_scan +#check M009_R6_latest_owner +#check M009_R6_parent_reason_survives +#check M009_R6_final_leakage_iff +#check M009_R7_accepted_example +#check M009_R7_rejected_example +#check M009_R7_nonvacuous +#check MAT009.Diagnostic.scan_first_owner_sticky + +theorem parent_reason_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (reason : String) (h : parent reason) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + exact ⟨reason, M009_R6_parent_reason_survives parent rows reason h⟩ + +theorem shared_campaign_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (campaign : String) + (htrain : ∃ row ∈ rows, + row.role = .train ∧ row.campaign = campaign) + (hholdout : ∃ row ∈ rows, + row.role = .holdout ∧ row.campaign = campaign) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + refine ⟨leakageReason, Or.inr ?_⟩ + exact (M009_R6_final_leakage_iff parent rows).2 + (Or.inl ⟨campaign, htrain, hholdout⟩) + +#print axioms M009_R1_initial +#print axioms M009_R2_assignment_overwrite +#print axioms M009_R3_cross_role_trigger +#print axioms M009_R4_stickiness +#print axioms M009_R5_final_set_intersection +#print axioms M009_R5_parent_union +#print axioms M009_R6_cross_trigger_in_finite_scan +#print axioms M009_R6_arbitrary_finite_scan +#print axioms M009_R6_latest_owner +#print axioms M009_R6_parent_reason_survives +#print axioms M009_R6_final_leakage_iff +#print axioms M009_R7_accepted_example +#print axioms M009_R7_rejected_example +#print axioms M009_R7_nonvacuous +#print axioms parent_reason_blocks_any_scan +#print axioms shared_campaign_blocks_any_scan +#print axioms MAT009.Diagnostic.scan_first_owner_sticky +#print axioms MAT009.Diagnostic.first_owner_not_last_writer + +end MAT009.Consumer diff --git a/formal/sonification/mat009/audit/repair-audit-001/report.json b/formal/sonification/mat009/audit/repair-audit-001/report.json new file mode 100644 index 0000000..61fc97d --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/report.json @@ -0,0 +1,112 @@ +{ + "candidate_branch": "research/sonification-formal-001-mat009-verify", + "candidate_commit": "b07942c77bebb15c99d8a70f52397d4077694ea0", + "declaration_closure": { + "compiler_auxiliaries": 146, + "hashed_external_imports": 1303, + "named_intended_theorems": 22, + "other_safe_declarations": 110, + "project_compiler_axioms": 2, + "proof_modules": [ + "SplitModel", + "DiagnosticFirstOwner", + "TypedConsumer", + "ExactTypes", + "LeanAudit" + ], + "safe_transitive_axioms": [ + "Classical.choice", + "Quot.sound", + "propext" + ], + "theorems": 95, + "total": 351, + "unsafe_auxiliary_axioms": [ + "MAT009.initial._elambda_1", + "MAT009.step._elambda_1", + "lcProof", + "lcUnreachable", + "propext" + ], + "unsafe_generated_definitions": 144 + }, + "evidence_sha256": { + "lean_audit_source": "867bb9c70345c525239e6cadd6da3ec1f186f586f431855de67aadefa429882c", + "lean_receipt_manifest": "575f9996a160db4ff01b69a155f2210046ce7a40b4d2ffdd78ca7c13afeb73be", + "negative_control_manifest": "1e1efa7eb0d4aedc1e43f096cc2610a6bd2d733a69a1e0f35d91e78a86eae191", + "original_replay_manifest": "783d4d69de3fdfa810899143a3a2bf03f13e3bd3aa3eda935356763e404d8350", + "source_binding_manifest": "baf3401c300c062a31596e68a6f595978a8810c0f0b9d361445c75764e042b91" + }, + "findings": [], + "independent_checks": { + "compiler_axiom_proof_probe": { + "build_exit_codes": [ + 1 + ], + "diagnostic": "(kernel) invalid declaration, it uses unsafe declaration 'lcProof'", + "observation": "Lean kernel rejected a theorem of False using unsafe lcProof before the audit module compiled" + }, + "independent_cstage2_variation": { + "build_exit_codes": [ + 0, + 0, + 0, + 0, + 1 + ], + "expected_diagnostic": "project axiom declaration MAT009.auditor_false_cstage2", + "scanner_rejected": true, + "source_sha256": "c77760060706b3a50125a2a96a437a8bf874903328681b274eb4eab49f3e0b09" + }, + "named_axiom_reports_unchanged": true, + "receipt_verifiers": { + "lean_receipt": { + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "c419e181e2b8bbecddb22cfbf98b41d848f22f725d939ecafcafaf326fea32d4" + }, + "legacy_negative": { + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "8cb3c759e0dd871f132cc1524700e3908fbc88e38b5b8e39901fcbd5d9f87c21" + }, + "repair_receipt": { + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "698f48a34790f50ec4fb32e63e4c8e1dc143f5ce7a1c8383d56d18aa2ab99204" + }, + "source_binding": { + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "5a3750fcbab24ba5889a7a5439b5445d7484ac50a497ab546df22139462902b7" + }, + "source_receipts": { + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "2c408e885fa4ac144dbd6bffc148095f09f3e67db1fb054de95953589e56c816" + }, + "suffix_tests": { + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "149e983c325e1215d8fe411fd58fb9c0fa38bc5dfa119c4a6a92d44ee61e3e10" + } + }, + "theorem_types_unchanged": true, + "toolchain_import_hashes_unchanged": true + }, + "original_finding": { + "id": "MAT009-AUDIT-001", + "original_suffix_mutant_sha256": "1b2e633163118f65974db85be1416ea44af7126d303f5864d5d1f993dc547b71", + "report_sha256": "70ddf22c27e43059c069565c7e99b7095c29f348142407f307ba92833f7eed8f", + "verdict": "FAIL" + }, + "remaining_obligations": [ + "REFINEMENT_PROVED remains OPEN for frozen MAT009 and direct MAT008 parent.", + "The model omits child skip guards, remaining reasons, diagnostics beyond the scoped registry, and CPython behavior.", + "No physical experimental validity or independence follows from these software proofs.", + "Future proof-source rebaselines require fresh review: an absent source range alone does not universally authenticate compiler origin, though the current four model sources contain no run_cmd or unsafe declarations and are commit-pinned." + ], + "schema": "sonification-mat009-independent-repair-audit/v1", + "scope": "MAT009-AUDIT-001 standalone Lean axiom gate and exact frozen mathematical-model receipt", + "verdict": "PASS" +} diff --git a/formal/sonification/mat009/audit/repair-audit-001/suffix2-result.json b/formal/sonification/mat009/audit/repair-audit-001/suffix2-result.json new file mode 100644 index 0000000..0bf05b6 --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/suffix2-result.json @@ -0,0 +1,75 @@ +{ + "candidate_commit": "b07942c77bebb15c99d8a70f52397d4077694ea0", + "jobs": [ + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/SplitModel.olean", + "SplitModel.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/repair-audit-001/suffix2-work", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/DiagnosticFirstOwner.olean", + "DiagnosticFirstOwner.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/repair-audit-001/suffix2-work", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/TypedConsumer.olean", + "TypedConsumer.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/repair-audit-001/suffix2-work", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "9078e77bdd2580d1ce506f685136b42d01255a0ebd4177589a7d493b4ad06522" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/ExactTypes.olean", + "ExactTypes.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/repair-audit-001/suffix2-work", + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "argv": [ + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean", + "--error=warning", + "-o", + "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/LeanAudit.olean", + "LeanAudit.lean" + ], + "cwd": "/home/trent/sonification-formal-001-mat009/formal/sonification/mat009/audit/repair-audit-001/suffix2-work", + "exit_code": 1, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "2f67d8b6614f70178fd99565fc5db071b3a31da9862e79d694ac5490a0b1d03e" + } + ], + "lean_executable_sha256": "92c3d35b5bfaa5e0fea413a775d504cf46cd95e1345df61c2274f76779e7e023", + "mutant_sha256": "c77760060706b3a50125a2a96a437a8bf874903328681b274eb4eab49f3e0b09", + "mutation": "axiom auditor_false_cstage2 : False; theorem auditor_false_proof_cstage2 : False := auditor_false_cstage2", + "rejected_by_scanner": true, + "scanner_sha256": "867bb9c70345c525239e6cadd6da3ec1f186f586f431855de67aadefa429882c" +} diff --git a/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/DiagnosticFirstOwner.lean b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/DiagnosticFirstOwner.lean new file mode 100644 index 0000000..7283ce6 --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/DiagnosticFirstOwner.lean @@ -0,0 +1,78 @@ +import Std + +/-! +The MAT009 diagnostic hash and event registries use the same `setdefault` +ownership rule. This abstract registry models one such identity map. It is +separate from the campaign split model and assumes identities were already +validated before registration. +-/ + +namespace MAT009.Diagnostic + +abbrev Owner := String × String -- campaign and role +abbrev Registry := String → Option Owner + +def empty : Registry := fun _ => none + +def register (registry : Registry) (identity : String) + (candidate : Owner) : Registry := + fun key => + if key = identity then + match registry key with + | none => some candidate + | some first => some first + else + registry key + +def scan (registry : Registry) : List (String × Owner) → Registry + | [] => registry + | (identity, candidate) :: rest => + scan (register registry identity candidate) rest + +theorem register_first_owner (registry : Registry) + (identity : String) (candidate first : Owner) + (h : registry identity = some first) : + (register registry identity candidate) identity = some first := by + simp [register, h] + +theorem register_new_owner (registry : Registry) + (identity : String) (candidate : Owner) + (h : registry identity = none) : + (register registry identity candidate) identity = some candidate := by + simp [register, h] + +theorem register_other_identity (registry : Registry) + (identity key : String) (candidate : Owner) + (h : key ≠ identity) : + (register registry identity candidate) key = registry key := by + simp [register, h] + +theorem register_preserves_existing (registry : Registry) + (identity key : String) (candidate first : Owner) + (h : registry key = some first) : + (register registry identity candidate) key = some first := by + by_cases hkey : key = identity + · subst key + simp [register, h] + · simp [register, hkey, h] + +theorem scan_first_owner_sticky (registry : Registry) + (updates : List (String × Owner)) (key : String) (first : Owner) + (h : registry key = some first) : + (scan registry updates) key = some first := by + induction updates generalizing registry with + | nil => simpa [scan] using h + | cons update rest ih => + rcases update with ⟨identity, candidate⟩ + exact ih (registry := register registry identity candidate) + (register_preserves_existing registry identity key candidate first h) + +-- A second claimant cannot change the first owner of a diagnostic identity. +theorem first_owner_not_last_writer : + (scan empty + [("D", ("CAMPAIGN_A", "TRAIN")), + ("D", ("CAMPAIGN_B", "HOLDOUT"))]) "D" = + some ("CAMPAIGN_A", "TRAIN") := by + simp [scan, register, empty] + +end MAT009.Diagnostic diff --git a/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/DiagnosticFirstOwner.olean b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/DiagnosticFirstOwner.olean new file mode 100644 index 0000000000000000000000000000000000000000..c37c782169014dfbc0b84afdb41183412032a707 GIT binary patch literal 79608 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 BV2uC( literal 0 HcmV?d00001 diff --git a/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/ExactTypes.lean b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/ExactTypes.lean new file mode 100644 index 0000000..7e5be3e --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/ExactTypes.lean @@ -0,0 +1,98 @@ +import TypedConsumer + +/-! +Independent typed uses of the intended MAT009 model propositions. A theorem +with the same name but a weaker type, such as `True`, cannot satisfy these +consumers. These are statements about eligible-row mathematical models only. +-/ + +namespace MAT009.ExactTypes +open MAT009 + +example (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := + M009_R1_initial parent role campaign lab reason + +example (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := + M009_R2_assignment_overwrite s row + +example (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := + M009_R3_cross_role_trigger s row + +example (s : State) (row : Row) (role : Role) + (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := + M009_R4_stickiness s row role campaign lab reason + +example (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := + M009_R5_final_set_intersection s + +example (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := + M009_R5_parent_union s + +example (parent : ReasonSet) (rows : List Row) (role : Role) + (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := + M009_R6_arbitrary_finite_scan parent rows role campaign lab reason + +example (parent : ReasonSet) (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = lastRole rows campaign := + M009_R6_latest_owner parent rows campaign + +example (parent : ReasonSet) (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := + M009_R6_final_leakage_iff parent rows + +example : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := + M009_R7_nonvacuous + +example (registry : MAT009.Diagnostic.Registry) + (updates : List (String × MAT009.Diagnostic.Owner)) + (key : String) (first : MAT009.Diagnostic.Owner) + (h : registry key = some first) : + (MAT009.Diagnostic.scan registry updates) key = some first := + MAT009.Diagnostic.scan_first_owner_sticky registry updates key first h + +end MAT009.ExactTypes diff --git a/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/ExactTypes.olean b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/ExactTypes.olean new file mode 100644 index 0000000000000000000000000000000000000000..4578b4995bfe97d22911521c67f8b4607b3e4f61 GIT binary patch literal 17840 zcmb7L3wTu3wVni!@Cp%82Lv2IX%xhO1QJCIkGyyWNHE}oIhmX!1M})U!o&hb)RNC? z87SI_tpsjWE?2z4dxcc74N@^EYD9%pZ4IqpXhEYWMtRu1_Fn(wUTbUkCjcs+AMX8Od849B?iiIen68ICl4 zVn%66N#?}N3F9@*VyRj7-hCEJb+$rcOt4tK@4?i-?tGr_aR&Ln7Mmq8LDZFpoq1}@ z`u<>3u>zqks4&XMfmy*!M-!ojT3tTD=vqdwYveCW@=FQo=aP^7l&CgIB;_1zmfxY-# z3xyZxj_hzWsG^+sBFt0I=sfl8Up6iqmrl1?Es2&^E-zrDa?+0So4${fvaKqK3-f(af6n)5&SPt#lhh-2dt>|ola%R}r9Qv2QVZ&QD#6%JS8H4!n8xLTTOLdDuOItx@?hBvbbkR~hks`;&mHpqHBY5d zWwHnD1w^~Ky`>?SF1$3gn~(V-jL!Xs2L5n5JQIA!q!ktm@H0No_mt{BUHtI`Z9$qV zY@vW2uzAaD!3y2x^oWjFDhkywvk7(GWfQr==M6Z6qJsv;+NM%XuU~ifUf~Q@$lC&9 zklSda+e$(~n`T>~Ys+=N!!paq?QvMRbip!at0 zj3xLBslcZBbz2}PI+9yh8n9_4Ucs!poaN3EmwuDqyTazy#I53w)1kSPp~4N1t7cX)OIuIXzR~(g>fBh5?r-I|TlqTOFYdW0KV%uM(|wJ6 zU$LQ_+W!h75C>2uc5$u+#i$igrTM^^BdD(I=RAK!nD663Kdf(V*zTn3q}Rmd<~)J% z1H|~9?sfZ|uISQ%Xu9ZFdZ~EK*q7JGU9+x|u9N-fuR!Emr^n^==u?Fkor#w0PGg<| z##e{Tuif46)Y)5m=K-&9C`6?3_{J<#4j=o}fd;oz^%y=zl=;52xGblDSwfomSOV zu1mkL_EYhCyZR;9?vs^Ap;y4=<~V{M81098rS6v<-Vrp(b@8u;c}G4p_Mzo#dPdjx zjdAq4ahQPE*W@qY3j&Ps>tLRvp9G$0|Akkkw*-;z&<;Sf2d&@dXg*`JOFmn&ic1z_ z{mCb88oFWSGQ`Kn<>vT+9|#>i?DP6fkulo6jrpAV7e_`;`%MXSTH@#+Zv&xMfB+G4*W^!ulx#sm^*mNp;IB!q4>Z~Am*76@tGQw__CPC&Um4G#`=|iYupUG zBV2Bd55^x5UQdGYHXJ5J_42c5?MP^Tp1bOoIvWyR6yV7?~%rmK5hmh%(nq+YK4HT#48 z8W8KJ=?g_Bp_|1)eqbG7XP)d0L!arl_KgvAo!SAii?#i1Fz=ua+kM6bLD%)+S%hUEgFfp zj`+3oF1XHgZp-pJ+Huesk?^1Eriy*JQxiXZY4 z5cx^;EAuj2^0k6*pz>#C?(E&wADoNs$J4mn><{`C5dBMRTpSezTJYl8yKDPbFz>U= z7yWhP4>Qxqerl(>IC_}3fzWlv>=DGK^w2L_n0MCsR~G+cYnx1`q?dAK>~TIwQCNWJ zkEMEVz4*?9Kcgz7TN6hY{Q`(_G<*8o9Hy7;hWygVJjZ5# zo7p32Oas-Set>-suqWSKq6MN|n(S=j`;)FxaajN9Gpl><+&zk_lbvZ?Zf<|@0>SV0 zdZKGXBYy?+Y{}g>Fnw0}E8vgB;fMb~#KDkeWgK9C6Z4!J{LJ0W$Cu0JFBAuiYaqrq zJxUg-B$(rMm2zk#Upw=pT&?1jZ$8@m}iFPJYpZL<4r+{(viQ`{x`ti4g#7F(98rKc`U!xsZ zx9nfDHv6e$`-5~JU2ov~u>Lso=kG7ySNp+Y@V3O@CHt}70Al~-6Wi)Jnnx=)G@8+l zltC&Um1F;Wjceo94baKra$|du4*EY3dA>mN2k_K^_#^Chn0d-;Rz3S%Nv@api3fQU z2)lifM@-m;EKYoN%+tvD!q>Uq&Uk2th{CY50RUn?IiVRLhiNk1j z>R=U@@N=P!559S$9F}A^=4s$n>Q;-eTRi9zt5mV?_R~sFKJ-x+iMJShjOmLKhv!e| zQ${t&{(3Gq$NO652M*(Nhj_GB?)6uRxc^(aZOp%T?{(Qj4h@&hN4lxkC_l}*BUuM1 z7j&Y`y<9wDDsg(Wpx1vXZMxm)x1DuzZhkl4f9IHNx=#Ar;^<=^0K|M)=JkuISG1Wa z#%8@%=6z@IX*0=h;_Dj@=R6aK|Jkzf67o5he_A};mrDt z*0ofDc!sK~7T^#*_v>OgEuQ6yhsz?xy2L}l@@Z9b#Uo?G+M4(?n75d5Z}WR4CpP^k zH*eJ5wOnrQZx~NNjH?*BQAML(GxN?bSy_?O>(Gm2Ht8h|i{0MHUqIxsLh)M3$ssew zJ&Spsy>;ZSSJwRM0`b%J3NA-HU)W&XHSX1W57BjsC-$E}>_dZ6XR3?VkK!44r8$l@ z%)5;-|DKymoj?EV3F0NcTDjaDM~o97){o0Q-W49@T%l%si6r>Q59nF1Rq?uOsq4Vg zBSz*!uYk+VddR0h%$v%;u2M#w8s_VkviYWbpLY{<8sg|+o&aLLP&(@U3Oa^Sr=9s8 zKh^y1s2wfKp<}bf?iV(yAP$@SYq207_XioG84(#q#NOR zubBBiJwEiRekZENQw7=oxkHKLH-3I zk7m2H61tZTqrC;pGvT|A19xA&XER;Dl)Y}v;rE*6EaD3@Pc7q-mEF9r74CYN_{iR- z81@?P!+db==y%`yA6zTv46*~`ABa34@{OB(GMPeh(m%^c6(1Yprzao&;<5K$j^^)T zE;r`^j7uQe%jt25SB+wcqILEyqx}))^KYK?#yxc@?~onjcViqK^jjeM?+jfy<@M9D zgec@eI#_pgFyFk@->v*=NS|-0!ll|vyf?ilNW_= zjt}NFAm%qsBo>c&7_5nz)x4%L>eVyvZ98*b8g<3&lhA96qla+^#P}2A9BERvH^#T^ zdga&Ac~1}BeAM>|`182j><{)^KUXt!KVw#@Fxqs402Ju_?q$?U6L<;_+_mf0);|96wgHE3&H|_F$d{ zVjZgHo7f|Wc(Yi~&RDs)adnUVJLEJ%_SD9(hy2I$1t8i@thU{vZ;)9sj>s3y%(L^Q zZ~7)AZ~rIk#ySHC`)Tzicw!n(c6TtJ^(QJ`e;)Y3{wFFoE+SsCyMW8h{Q&$x#K{o~ z1id2DINfTm5bbpA2l`zN^On^-Ir+tx&elS&F^(SAqrhwE2651Ey;FS8AU-q54vRgz zm>B5mpw7ub)FD5S-#VDTq0#x!4<8iGBo6X3BlY6`LhXY*14O@=ueMI0UEe<1Xvj_|~=y_f9*ojT^*HaFCC zc9ymeI?XY3C=R#}&&4K=I(BN^ln-RssNJ9sgdG9#8pH2((3+=9T$658aZ6Yr|fgQzMZXO57S3t~ztYh++*i?UnUW9ow^R~X%@zN_Dbe-Cn+T# z)W|Vom}Q)yXBn;h9QRi8{?qSo`V4v*TyFLcaRZ{?kX|euw2P1V*1tG@^RjihHPESx zql5eb#C#CYg+mKthzUYtKWJgzojrRNjd*f=G=HUxi9H^$jsRkO&v6E5y)QNv0Ww)0 zq=WTk9`g+C(X9em7lcJ^a^ zHy+uuf%qvtnBRcNa{vTe zJ_BN23wgx%eWi=Ut7>|Y8OSg9h>wnfd>;<$u2X_MPNH@|4;&<>uJ^ zAL~&d@`+e4hz~|+AvevXIhN0M2E@D??2H@6cOLU*)`Y$~``o-2p;sM85A6-a{I*c{ ziw{OR`6CI+-UjA5oABt!yS`cYA=RLEft^6)KZp3@ajJa7U*PvvI=j59p!RNMK1-V7 zx1{zyHoflyzl7ZxTyAb3v_BC2V0u(f*-n2+2lo4zZ^v(5j;zVwD$OPPF>ZkvzZG7W z-pLsaxg;mvI_7I+oc7kxgS+-$e~v0pJ9osfAN)YfPY$>EwE;rbRZjW=y|i&EUIR{# zd8YKEg=NsI;Bs@k;1>|OqBr{&_#C2f9O6qnzu~J66*sg`9rN0*cy!)%g-6ywuO*Hi z`V$cS>P}~Axo+sUXqS}n%Ac=qURLv~^K)gAr*^?Q0f_ldeaE{%FBb#BUq#j^do!4) zn9)0I@>5lrzxtT2Q+w2Kxj8N{qdRy-nkb#?QwLv zQ3Y`T#mZ0~cjoYa1Q0*+VCpR@F4jS#-+JxTzQa_Dt`~4Q^4k0h7ZyIfCncM%lb=4m zZuV3D5JuDi4x$^xv7$`8fuR+c9tgyl*1PC#WBxDKUsce}){B2%lW1v+ql>r#5nu7n zA}GF&%yEkEuf(G$X^YW++XUtRs@0zzw!8KnpbFA|E{Fe3oBr_6-1H;ze(677H~Wuu z5)kW*IpY0s(CcwJ#CNEYgmsWtw=v(K*V}%5t^Ys~)kzTj6ZZp=kLZ20;OpGnGhYky zbTHm(8+LH<8_VVJAiGo3mA_`Y5icOdf!L3Vk81SN9H;Io<)x7^es<=&{Y3dA-EaA= z{G5R7MjiknAJ9A#pDZffb%$K8$o|je=C~ja1F?Rb=hn+LL)`J)WE=A=NPl2r-qC|PRUvy3S0L;z zaRw`O$I_s8sd$ZI;A>`{cE-_(WitwIedO0vh3vIu#P0W4M*s&hXGx{BIA*G%ctfw4 zc?bDVCu~}Dk6c!fUL=klo|^%&E}kpiHBQ$8a7kKWY}Y2{v!DCLbGr4u==_Ct1R_89 zLV*h6Gxw7Y=CNj~cueYlr0wQmx2#2+^0?gGuHXkkM=VdJ-SKp)nQup33Fi6beiMnVE+R|-ZJ<@IZG_GqHf7JK`-fc z<=^Nnh3V6l_Lj>f(#zsgX4Hica#?Gfy+)N8{}Mri6PPV!cGm9m+4kEswJYk6Nbe zJT3Q$WRH!npPgIfdkVUq#n%y+H3^Y(e_J*7ZRSs~^L6;s+K@1;DI;8 zJ>#be;s9C_m37ZsAE3^yS17DzEEuTH8yVBCROj0m3$9Y< z^}wsuc^hM$Rh@S*+6Srgl)(y{8S}1D=S_?mL)3XaW5ZB&o;pmS3@>m+`ETfvyh?;{%+ef++zm9d!Ldo?oJ`2A1~V>@G* z-=DNG7W4aoM#eOLzTU=I%+HlA{2aA`F^!)a)-e|Ib2ckKkE&tpVBE&fV^a9}M1(Pk z_u&!7Jl?-1@jflg*vc5;{Yw_F)9V>4c%5tIbzYdUg|V8~KQ+8=XlJzZ{Mf{p#`8x9 h=hbS?6RnJSJWd-KX>6uhdRS5uR68U8nX!fI{|mE#@wWf~ literal 0 HcmV?d00001 diff --git a/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/LeanAudit.lean b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/LeanAudit.lean new file mode 100644 index 0000000..d798ebc --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/LeanAudit.lean @@ -0,0 +1,89 @@ +import ExactTypes +import Lean + +/-! +Enumerate every declaration whose origin is a MAT009 proof module, including +helpers and typed consumers. The script that runs this module checks the +inventory. `collectAxioms` traverses each declaration's logical dependencies. +-/ + +open Lean Elab Command + +run_cmd do + let env ← getEnv + let origins := #[ + `SplitModel, `DiagnosticFirstOwner, `TypedConsumer, `ExactTypes, + env.mainModule + ] + for mod in origins do + unless mod == env.mainModule || (env.getModuleIdx? mod).isSome do + throwError "missing required imported module {mod}" + logInfo m!"MAT009_MODULE {mod}" + for mod in env.header.moduleNames do + logInfo m!"MAT009_IMPORT {mod}" + let allowedLogical := #[`propext, `Quot.sound, `Classical.choice] + /- These unsafe axioms are emitted by Lean's compiler for the two recursive + model functions. `lcProof` and `lcUnreachable` are compiler mechanisms used + only by unsafe generated definitions, never by logical theorems. -/ + let allowedCompiler := #[`lcProof, `lcUnreachable, + `MAT009.initial._elambda_1, `MAT009.step._elambda_1] + let mut seen : Nat := 0 + let mut theorems : Nat := 0 + let mut compilerAxioms : Nat := 0 + let declarations := env.checked.get.constants.toList.mergeSort fun a b => + decide (a.1.toString ≤ b.1.toString) + for (name, info) in declarations do + let origin := match env.getModuleIdxFor? name with + | some idx => env.header.moduleNames[idx.toNat]! + | none => env.mainModule + if origins.contains origin then + seen := seen + 1 + if info matches .thmInfo _ then + theorems := theorems + 1 + let generatedName := name.toString.endsWith "_cstage1" || + name.toString.endsWith "_cstage2" || + (name.toString.splitOn "._closed_").length > 1 || + (name.toString.splitOn "._elambda_").length > 1 + let unsafeDef : Bool := match info with + | .defnInfo d => d.safety == DefinitionSafety.unsafe + | _ => false + let unsafeAxiom : Bool := match info with + | .axiomInfo a => a.isUnsafe + | _ => false + let hasSourceRange := (← findDeclarationRangesCore? name).isSome + let compilerAux := (unsafeDef || unsafeAxiom) && !hasSourceRange + let typeStr ← liftTermElabM do + pure (← Lean.Meta.ppExpr info.type).pretty + if info matches .axiomInfo _ then + let expectedType : Option String := + if name == `MAT009.initial._elambda_1 then + some "String → Option MAT009.Role" + else if name == `MAT009.step._elambda_1 then + some "MAT009.State → MAT009.Row → String → Option MAT009.Role" + else + none + unless compilerAux && expectedType == some typeStr do + throwError "project axiom declaration {name}" + compilerAxioms := compilerAxioms + 1 + if unsafeDef && !(compilerAux && generatedName) then + throwError "unsafe project definition {name}" + let axioms ← collectAxioms name + for ax in axioms do + unless allowedLogical.contains ax || + (compilerAux && allowedCompiler.contains ax) do + throwError "unapproved transitive axiom {ax} in {name} (origin {origin})" + let row := Json.mkObj [ + ("origin", toJson origin.toString), + ("declaration", toJson name.toString), + ("kind", toJson (if compilerAux then "compiler_auxiliary" else + if info matches .thmInfo _ then "theorem" else "non_theorem")), + ("is_axiom", toJson (info matches .axiomInfo _)), + ("unsafe_axiom", toJson unsafeAxiom), + ("unsafe_definition", toJson unsafeDef), + ("has_source_range", toJson hasSourceRange), + ("type", toJson typeStr), + ("axioms", toJson (axioms.map Name.toString))] + logInfo m!"MAT009_DECL {row.compress}" + if seen == 0 || theorems == 0 || compilerAxioms != 2 then + throwError "incomplete proof inventory" + logInfo m!"MAT009_AUDIT declarations={seen} theorems={theorems}" diff --git a/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/SplitModel.lean b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/SplitModel.lean new file mode 100644 index 0000000..e03d02f --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/SplitModel.lean @@ -0,0 +1,382 @@ +import Std + +/-! +An abstract model of the MAT009 child split check after the campaign, role, +and lab eligibility guards have succeeded. A `Row` is already eligible; this +file does not model Python values, skipped rows, or the MAT008 implementation. +Parent reason IDs are supplied as a predicate and remain present throughout +the child scan. The source-family intersection check is performed by +`finalize`, after all row steps. +-/ + +namespace MAT009 + +inductive Role where + | train + | holdout + deriving DecidableEq, Repr + +structure Row where + campaign : String + lab : String + role : Role + deriving Repr + +abbrev ReasonSet := String → Prop + +def crossReason : String := "CAMPAIGN_CROSSES_TRAIN_HOLDOUT" +def leakageReason : String := "SOURCE_FAMILY_LEAKAGE_ACROSS_SPLITS" + +structure State where + -- The most recently processed role for each campaign. + owner : String → Option Role + -- Historical membership is never deleted when `owner` is overwritten. + campaigns : Role → String → Prop + labs : Role → String → Prop + crossed : Prop + parent : ReasonSet + +def initial (parent : ReasonSet) : State where + owner := fun _ => none + campaigns := fun _ _ => False + labs := fun _ _ => False + crossed := False + parent := parent + +def step (s : State) (row : Row) : State where + owner := fun key => if key = row.campaign then some row.role else s.owner key + campaigns := fun role key => + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign) + labs := fun role key => + s.labs role key ∨ (role = row.role ∧ key = row.lab) + crossed := s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role + parent := s.parent + +def scan (s : State) : List Row → State + | [] => s + | row :: rest => scan (step s row) rest + +-- Search from the end: the first matching row there is the latest owner. +def lastRole : List Row → String → Option Role + | [], _ => none + | row :: rest, key => + match lastRole rest key with + | some role => some role + | none => if row.campaign = key then some row.role else none + +def splitIntersection (members : Role → String → Prop) : Prop := + ∃ key, members .train key ∧ members .holdout key + +def familyLeakage (s : State) : Prop := + splitIntersection s.campaigns ∨ splitIntersection s.labs + +theorem familyLeakage_step_sticky (s : State) (row : Row) : + familyLeakage s → familyLeakage (step s row) := by + intro h + rcases h with ⟨key, htrain, hholdout⟩ | ⟨key, htrain, hholdout⟩ + · exact Or.inl ⟨key, Or.inl htrain, Or.inl hholdout⟩ + · exact Or.inr ⟨key, Or.inl htrain, Or.inl hholdout⟩ + +structure Final where + parent : ReasonSet + crossed : Prop + leakage : Prop + +def finalize (s : State) : Final where + parent := s.parent + crossed := s.crossed + leakage := familyLeakage s + +def Final.childReason (f : Final) (reason : String) : Prop := + (reason = crossReason ∧ f.crossed) ∨ + (reason = leakageReason ∧ f.leakage) + +def Final.hasReason (f : Final) (reason : String) : Prop := + f.parent reason ∨ f.childReason reason + +inductive Status where + | blocked + | structuralOnlyUnauthenticated + deriving DecidableEq, Repr + +noncomputable def Final.status (f : Final) : Status := by + classical + exact if (∃ reason, f.hasReason reason) then + .blocked + else + .structuralOnlyUnauthenticated + +theorem Final.status_blocked_iff (f : Final) : + f.status = .blocked ↔ ∃ reason, f.hasReason reason := by + classical + simp [Final.status] + +theorem Final.status_structural_iff (f : Final) : + f.status = .structuralOnlyUnauthenticated ↔ + ∀ reason, ¬ f.hasReason reason := by + classical + simp [Final.status, not_exists] + +-- M009-R1: the child scan starts empty, with exactly the supplied parent set. +theorem M009_R1_initial (parent : ReasonSet) (role : Role) + (campaign lab reason : String) : + (initial parent).owner campaign = none ∧ + ¬ (initial parent).campaigns role campaign ∧ + ¬ (initial parent).labs role lab ∧ + ¬ (initial parent).crossed ∧ + ((initial parent).parent reason ↔ parent reason) := by + simp [initial] + +-- M009-R2: assignment is last writer wins; both historical sets only grow. +theorem M009_R2_assignment_overwrite (s : State) (row : Row) : + (step s row).owner row.campaign = some row.role ∧ + (∀ key, key ≠ row.campaign → (step s row).owner key = s.owner key) ∧ + (∀ role key, + (step s row).campaigns role key ↔ + s.campaigns role key ∨ (role = row.role ∧ key = row.campaign)) ∧ + (∀ role key, + (step s row).labs role key ↔ + s.labs role key ∨ (role = row.role ∧ key = row.lab)) := by + refine ⟨?_, ?_, ?_, ?_⟩ + · simp [step] + · intro key h + simp [step, h] + · intro role key + rfl + · intro role key + rfl + +-- M009-R3: the row-step trigger is the prior owner having the other role. +theorem M009_R3_cross_role_trigger (s : State) (row : Row) : + (step s row).crossed ↔ + s.crossed ∨ + ∃ previous : Role, + s.owner row.campaign = some previous ∧ previous ≠ row.role := by + rfl + +-- M009-R4: a later row cannot remove split membership or an earlier reason. +theorem M009_R4_stickiness (s : State) (row : Row) + (role : Role) (campaign lab reason : String) : + (s.campaigns role campaign → (step s row).campaigns role campaign) ∧ + (s.labs role lab → (step s row).labs role lab) ∧ + (s.crossed → (step s row).crossed) ∧ + (familyLeakage s → familyLeakage (step s row)) ∧ + ((step s row).parent reason ↔ s.parent reason) := by + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · intro h + exact Or.inl h + · exact familyLeakage_step_sticky s row + · rfl + +-- M009-R5: source-family leakage is computed only at finalization. +theorem M009_R5_final_set_intersection (s : State) : + (finalize s).childReason leakageReason ↔ + (∃ key, s.campaigns .train key ∧ s.campaigns .holdout key) ∨ + (∃ key, s.labs .train key ∧ s.labs .holdout key) := by + simp [Final.childReason, finalize, familyLeakage, + splitIntersection, crossReason, leakageReason] + +theorem M009_R5_parent_union (s : State) : + (finalize s).hasReason leakageReason ↔ + s.parent leakageReason ∨ familyLeakage s := by + simp [Final.hasReason, Final.childReason, finalize, + crossReason, leakageReason] + +theorem parent_reason_survives_finalization (s : State) + (reason : String) : + s.parent reason → (finalize s).hasReason reason := by + intro h + exact Or.inl h + +theorem scan_owner_last (s : State) (rows : List Row) (key : String) : + (scan s rows).owner key = + match lastRole rows key with + | some role => some role + | none => s.owner key := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + rw [scan, ih] + cases hlast : lastRole rest key with + | none => + by_cases hkey : row.campaign = key + · subst key + simp [lastRole, hlast, step] + · simp [lastRole, hlast, step, hkey, Ne.symm hkey] + | some role => + simp [lastRole, hlast] + +theorem scan_campaigns_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).campaigns role key ↔ + s.campaigns role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.campaign = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.campaign = key) ↔ + (row.role = role ∧ row.campaign = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.campaign = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_labs_iff (s : State) (rows : List Row) + (role : Role) (key : String) : + (scan s rows).labs role key ↔ + s.labs role key ∨ + ∃ row ∈ rows, row.role = role ∧ row.lab = key := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + have hhead : + (∃ r ∈ row :: rest, r.role = role ∧ r.lab = key) ↔ + (row.role = role ∧ row.lab = key) ∨ + ∃ r ∈ rest, r.role = role ∧ r.lab = key := by + simp + rw [scan, ih, hhead] + simp [step, eq_comm, or_assoc, or_left_comm, or_comm] + +theorem scan_parent (s : State) (rows : List Row) (reason : String) : + (scan s rows).parent reason ↔ s.parent reason := by + induction rows generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan, step] using (ih (s := step s row)) + +theorem scan_crossed_sticky (s : State) (rows : List Row) : + s.crossed → (scan s rows).crossed := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (Or.inl h) + +theorem scan_familyLeakage_sticky (s : State) (rows : List Row) : + familyLeakage s → familyLeakage (scan s rows) := by + induction rows generalizing s with + | nil => simp [scan] + | cons row rest ih => + intro h + exact ih (s := step s row) (familyLeakage_step_sticky s row h) + +theorem scan_append (s : State) (before after : List Row) : + scan s (before ++ after) = scan (scan s before) after := by + induction before generalizing s with + | nil => rfl + | cons row rest ih => + simpa [scan] using (ih (s := step s row)) + +-- A cross-role row anywhere in a finite scan makes the final reason sticky. +theorem M009_R6_cross_trigger_in_finite_scan (s : State) + (before after : List Row) (row : Row) + (h : ∃ previous : Role, + (scan s before).owner row.campaign = some previous ∧ + previous ≠ row.role) : + (scan s (before ++ row :: after)).crossed := by + rw [scan_append, scan] + exact scan_crossed_sticky _ after (Or.inr h) + +-- M009-R6: these equations quantify over every finite eligible row scan. +theorem M009_R6_arbitrary_finite_scan (parent : ReasonSet) + (rows : List Row) (role : Role) (campaign lab reason : String) : + ((scan (initial parent) rows).campaigns role campaign ↔ + ∃ row ∈ rows, row.role = role ∧ row.campaign = campaign) ∧ + ((scan (initial parent) rows).labs role lab ↔ + ∃ row ∈ rows, row.role = role ∧ row.lab = lab) ∧ + ((scan (initial parent) rows).parent reason ↔ parent reason) := by + simp [scan_campaigns_iff, scan_labs_iff, scan_parent, initial] + +theorem M009_R6_latest_owner (parent : ReasonSet) + (rows : List Row) (campaign : String) : + (scan (initial parent) rows).owner campaign = + lastRole rows campaign := by + rw [scan_owner_last] + cases h : lastRole rows campaign with + | none => simp [initial] + | some role => rfl + +theorem M009_R6_parent_reason_survives (parent : ReasonSet) + (rows : List Row) (reason : String) : + parent reason → + (finalize (scan (initial parent) rows)).hasReason reason := by + intro h + apply parent_reason_survives_finalization + exact (scan_parent (initial parent) rows reason).2 h + +theorem M009_R6_final_leakage_iff (parent : ReasonSet) + (rows : List Row) : + (finalize (scan (initial parent) rows)).childReason leakageReason ↔ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.campaign = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.campaign = key)) ∨ + (∃ key, + (∃ row ∈ rows, row.role = .train ∧ row.lab = key) ∧ + (∃ row ∈ rows, row.role = .holdout ∧ row.lab = key)) := by + rw [M009_R5_final_set_intersection] + simp [scan_campaigns_iff, scan_labs_iff, initial] + +def noParent : ReasonSet := fun _ => False + +def cleanRows : List Row := + [{ campaign := "TRAIN_A", lab := "LAB_A", role := .train }, + { campaign := "HELD_B", lab := "LAB_B", role := .holdout }] + +def crossingRows : List Row := + [{ campaign := "SAME", lab := "LAB_A", role := .train }, + { campaign := "SAME", lab := "LAB_B", role := .holdout }] + +-- M009-R7: both structural outcomes have concrete finite witnesses. +theorem M009_R7_accepted_example : + (finalize (scan (initial noParent) cleanRows)).status = + .structuralOnlyUnauthenticated := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + cleanRows, noParent, crossReason, leakageReason] + +theorem M009_R7_rejected_example : + (finalize (scan (initial noParent) crossingRows)).status = + .blocked := by + classical + simp [Final.status, Final.hasReason, Final.childReason, finalize, + familyLeakage, splitIntersection, scan, step, initial, + crossingRows, noParent, crossReason, leakageReason] + +theorem M009_R7_nonvacuous : + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .structuralOnlyUnauthenticated) ∧ + (∃ rows : List Row, + (finalize (scan (initial noParent) rows)).status = + .blocked) := by + exact ⟨⟨cleanRows, M009_R7_accepted_example⟩, + ⟨crossingRows, M009_R7_rejected_example⟩⟩ + +-- Counterexample to replacing persistent set membership by the final owner. +theorem overwrite_retains_both_split_memberships : + let s := scan (initial noParent) crossingRows + s.owner "SAME" = some .holdout ∧ + s.campaigns .train "SAME" ∧ + s.campaigns .holdout "SAME" := by + simp [scan, step, initial, crossingRows, noParent] + +-- A parent's reason of the same ID survives even with no child intersection. +theorem parent_can_supply_leakage_reason : + let s := initial (fun reason => reason = leakageReason) + (finalize s).hasReason leakageReason ∧ + ¬ (finalize s).childReason leakageReason := by + simp [Final.hasReason, Final.childReason, finalize, initial, + familyLeakage, splitIntersection, crossReason, leakageReason] + +axiom auditor_false_cstage2 : False +theorem auditor_false_proof_cstage2 : False := auditor_false_cstage2 + +end MAT009 diff --git a/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/SplitModel.olean b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/SplitModel.olean new file mode 100644 index 0000000000000000000000000000000000000000..52987f03e52603a56424ffe81bc32d6c0351d05e GIT binary patch literal 529912 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

Ve-(Xyoy{#f1H>5xAlB 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 EKeAk3=>Px# literal 0 HcmV?d00001 diff --git a/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/TypedConsumer.lean b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/TypedConsumer.lean new file mode 100644 index 0000000..2158aca --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/TypedConsumer.lean @@ -0,0 +1,65 @@ +import SplitModel +import DiagnosticFirstOwner + +/-! +A separate import consumer for the MAT009 split model. These declarations +type-check the public R1–R7 interface and derive blocked outcomes from the +generic finite-scan and parent-reason theorems. +-/ + +namespace MAT009.Consumer + +#check M009_R1_initial +#check M009_R2_assignment_overwrite +#check M009_R3_cross_role_trigger +#check M009_R4_stickiness +#check M009_R5_final_set_intersection +#check M009_R5_parent_union +#check M009_R6_cross_trigger_in_finite_scan +#check M009_R6_arbitrary_finite_scan +#check M009_R6_latest_owner +#check M009_R6_parent_reason_survives +#check M009_R6_final_leakage_iff +#check M009_R7_accepted_example +#check M009_R7_rejected_example +#check M009_R7_nonvacuous +#check MAT009.Diagnostic.scan_first_owner_sticky + +theorem parent_reason_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (reason : String) (h : parent reason) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + exact ⟨reason, M009_R6_parent_reason_survives parent rows reason h⟩ + +theorem shared_campaign_blocks_any_scan (parent : ReasonSet) + (rows : List Row) (campaign : String) + (htrain : ∃ row ∈ rows, + row.role = .train ∧ row.campaign = campaign) + (hholdout : ∃ row ∈ rows, + row.role = .holdout ∧ row.campaign = campaign) : + (finalize (scan (initial parent) rows)).status = .blocked := by + apply (Final.status_blocked_iff _).2 + refine ⟨leakageReason, Or.inr ?_⟩ + exact (M009_R6_final_leakage_iff parent rows).2 + (Or.inl ⟨campaign, htrain, hholdout⟩) + +#print axioms M009_R1_initial +#print axioms M009_R2_assignment_overwrite +#print axioms M009_R3_cross_role_trigger +#print axioms M009_R4_stickiness +#print axioms M009_R5_final_set_intersection +#print axioms M009_R5_parent_union +#print axioms M009_R6_cross_trigger_in_finite_scan +#print axioms M009_R6_arbitrary_finite_scan +#print axioms M009_R6_latest_owner +#print axioms M009_R6_parent_reason_survives +#print axioms M009_R6_final_leakage_iff +#print axioms M009_R7_accepted_example +#print axioms M009_R7_rejected_example +#print axioms M009_R7_nonvacuous +#print axioms parent_reason_blocks_any_scan +#print axioms shared_campaign_blocks_any_scan +#print axioms MAT009.Diagnostic.scan_first_owner_sticky +#print axioms MAT009.Diagnostic.first_owner_not_last_writer + +end MAT009.Consumer diff --git a/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/TypedConsumer.olean b/formal/sonification/mat009/audit/repair-audit-001/suffix2-work/TypedConsumer.olean new file mode 100644 index 0000000000000000000000000000000000000000..2daddf4882e238ff29f668c1d76a20de546107fa GIT binary patch literal 29344 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 Th-_y=n8dofC1O6TV*URGuPP}Z literal 0 HcmV?d00001 diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/lean_receipt.stderr b/formal/sonification/mat009/audit/repair-audit-001/verification/lean_receipt.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/lean_receipt.stdout b/formal/sonification/mat009/audit/repair-audit-001/verification/lean_receipt.stdout new file mode 100644 index 0000000..5b9973f --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/verification/lean_receipt.stdout @@ -0,0 +1 @@ +{"AUDIT_ACCEPTED": "OPEN", "REFINEMENT_PROVED": "OPEN", "named_model_theorems": 22, "status": "MAT009_LEAN_EVIDENCE_BOUND", "toolchain_imports": 1303} diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/legacy_negative.stderr b/formal/sonification/mat009/audit/repair-audit-001/verification/legacy_negative.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/legacy_negative.stdout b/formal/sonification/mat009/audit/repair-audit-001/verification/legacy_negative.stdout new file mode 100644 index 0000000..b95b717 --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/verification/legacy_negative.stdout @@ -0,0 +1 @@ +{"REFINEMENT_PROVED": "OPEN", "detected": 6, "failed_development_attempts_retained": 2, "status": "MAT009_NEGATIVE_EVIDENCE_BOUND"} diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/repair_receipt.stderr b/formal/sonification/mat009/audit/repair-audit-001/verification/repair_receipt.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/repair_receipt.stdout b/formal/sonification/mat009/audit/repair-audit-001/verification/repair_receipt.stdout new file mode 100644 index 0000000..c8f34ce --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/verification/repair_receipt.stdout @@ -0,0 +1 @@ +{"REFINEMENT_PROVED": "OPEN", "corrected_gate_rejected": true, "detected": 7, "status": "MAT009_SUFFIX_AXIOM_REPAIR_BOUND", "vulnerable_gate_accepted": true} diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/result.json b/formal/sonification/mat009/audit/repair-audit-001/verification/result.json new file mode 100644 index 0000000..b43222e --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/verification/result.json @@ -0,0 +1,66 @@ +{ + "lean_receipt": { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/lean/verify.py", + "--lean", + "/home/trent/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "c419e181e2b8bbecddb22cfbf98b41d848f22f725d939ecafcafaf326fea32d4" + }, + "legacy_negative": { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/lean/verify_negative.py" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "8cb3c759e0dd871f132cc1524700e3908fbc88e38b5b8e39901fcbd5d9f87c21" + }, + "repair_receipt": { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/lean/verify_repair.py" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "698f48a34790f50ec4fb32e63e4c8e1dc143f5ce7a1c8383d56d18aa2ab99204" + }, + "source_binding": { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/source/source_bind.py" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "5a3750fcbab24ba5889a7a5439b5445d7484ac50a497ab546df22139462902b7" + }, + "source_receipts": { + "argv": [ + "python3", + "-B", + "formal/sonification/mat009/verify_evidence.py" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "2c408e885fa4ac144dbd6bffc148095f09f3e67db1fb054de95953589e56c816" + }, + "suffix_tests": { + "argv": [ + "python3", + "-m", + "pytest", + "-q", + "tests/test_sonification_formal_mat009_suffix_axiom.py" + ], + "exit_code": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "149e983c325e1215d8fe411fd58fb9c0fa38bc5dfa119c4a6a92d44ee61e3e10" + } +} diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/source_binding.stderr b/formal/sonification/mat009/audit/repair-audit-001/verification/source_binding.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/source_binding.stdout b/formal/sonification/mat009/audit/repair-audit-001/verification/source_binding.stdout new file mode 100644 index 0000000..631c1d9 --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/verification/source_binding.stdout @@ -0,0 +1 @@ +{"assurance": "SOURCE_SYNTAX_PINNED_ONLY", "commit": "0758a96360726aafbb07abed34620eda178407ae", "direct_parent_sha256": "e56563235d87da43293bc46661b077660538b476d2bb340a1d208cc59aaa5f08", "refinement_to_cpython": "OPEN", "selected_functions": 8, "status": "SOURCE_SYNTAX_MATCH", "tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", "target_sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", "tree": "a6a03e1227e666680d656b886201ee9dde9de32d"} diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/source_receipts.stderr b/formal/sonification/mat009/audit/repair-audit-001/verification/source_receipts.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/source_receipts.stdout b/formal/sonification/mat009/audit/repair-audit-001/verification/source_receipts.stdout new file mode 100644 index 0000000..b965f29 --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/verification/source_receipts.stdout @@ -0,0 +1 @@ +{"REFINEMENT_PROVED": "OPEN", "receipt_count": 4, "status": "MAT009_SOURCE_FINITE_RECEIPTS_BOUND"} diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/suffix_tests.stderr b/formal/sonification/mat009/audit/repair-audit-001/verification/suffix_tests.stderr new file mode 100644 index 0000000..e69de29 diff --git a/formal/sonification/mat009/audit/repair-audit-001/verification/suffix_tests.stdout b/formal/sonification/mat009/audit/repair-audit-001/verification/suffix_tests.stdout new file mode 100644 index 0000000..c2405a5 --- /dev/null +++ b/formal/sonification/mat009/audit/repair-audit-001/verification/suffix_tests.stdout @@ -0,0 +1,2 @@ +.. [100%] +2 passed in 0.03s From 64203ca18875d21ce1259957dd902ea7b7361bfb Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 12:38:31 +1030 Subject: [PATCH 21/22] formal(mat009): record scoped audit acceptance and CI toolchain --- .github/workflows/tests.yml | 6 + formal/sonification/README.md | 8 +- formal/sonification/mat009/README.md | 61 ++++++++ formal/sonification/theorem-map.json | 210 ++++++++++++++++++++++++++- 4 files changed, 283 insertions(+), 2 deletions(-) create mode 100644 formal/sonification/mat009/README.md diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 6082e19..56170ed 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -361,6 +361,12 @@ jobs: with: python-version: ${{ matrix.python-version }} cache: pip + - name: Install pinned Lean for formal receipt tests + run: | + curl -fsSL https://elan.lean-lang.org/elan-init.sh -o /tmp/elan-init.sh + sh /tmp/elan-init.sh -y --default-toolchain leanprover/lean4:v4.19.0 + echo "$HOME/.elan/bin" >> "$GITHUB_PATH" + "$HOME/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean" --version - run: python -m pip install --upgrade pip - run: python -m pip install -e .[dev] - run: python -m pytest diff --git a/formal/sonification/README.md b/formal/sonification/README.md index 9aacaef..1cf3229 100644 --- a/formal/sonification/README.md +++ b/formal/sonification/README.md @@ -15,14 +15,20 @@ Review stages: and axiom audit, preserved attempts and negative mutation controls. - PR C: source-sensitive Python refinement investigation and independent conformance tests; retain OPEN wherever semantic correspondence is unproved. -- Later increments: MAT-SPEC-008–010 admission, provenance and archive gates; +- Later increments: MAT-SPEC-008–009 admission and provenance gates; MAT-SPEC-001–006; D4-TIA; ETQ; remaining dependencies and operations. + MAT-SPEC-010 remains deferred. Use Python standard library commands from the repository root. Each stage's receipt identifies actual argv, working directory, tool bytes and version, input hashes, expected/observed obligations and original stdout/stderr. No result is accepted merely because a process exits zero. +The MAT-009 [scoped verification](mat009/README.md) now has a repaired Lean +axiom gate and a fresh independent PASS for the mathematical models. The +original independent FAIL is retained. Production Python refinement and the +general `MAT009.partition` target remain OPEN. + Historical releases and proof receipts are read-only inputs. The private protocol workspace is deliberately outside the public repository. Its bootstrap, contract loading, manifest verification, `init`, `validate`, diff --git a/formal/sonification/mat009/README.md b/formal/sonification/mat009/README.md new file mode 100644 index 0000000..e83ad67 --- /dev/null +++ b/formal/sonification/mat009/README.md @@ -0,0 +1,61 @@ +# MAT-009 scoped formal verification + +The frozen production subject is `mat-spec-009-v0.1.0`, commit +`0758a96360726aafbb07abed34620eda178407ae`. The source binder checks +that release and its direct MAT-008 parent against recorded Git bytes and +selected Python syntax. It does not prove source semantics. + +## Verified scope + +- The Lean 4.19.0 model proves eligible-row split membership, sticky conflict, + final intersection and parent reason union. A separate model proves the + validated diagnostic registry's first-owner behavior. There are 22 named + intended theorems; the full proof-module inventory has 351 declarations, + including 95 theorems and 146 compiler auxiliaries. +- Exact built-in finite conformance covers 4,096 four-row role, campaign and + lab combinations, plus named cases. The retained full repository run passed + 329 tests and 202 subtests before the audit repair. The focused post-repair + receipt suite passed 15 tests. +- The first independent audit **failed** with `MAT009-AUDIT-001`: a user axiom + and theorem of `False` ending `_cstage1` escaped the standalone Lean audit. + That report and its logs remain at `audit/report.json`. +- The repaired gate rejects that exact mutant and an independent `_cstage2` + variation. Seven negative controls passed. The fresh independent audit of + candidate `b07942c77bebb15c99d8a70f52397d4077694ea0` reports **PASS for + this scoped mathematical audit gate** in `audit/repair-audit-001/report.json`. + +The audit checks every declaration from the five proof modules. Safe +declarations may depend only on `propext`, `Quot.sound` and +`Classical.choice`. Two exact unsafe compiler axioms and the `lcProof` and +`lcUnreachable` compiler mechanisms are disclosed in `lean/PROOF_NOTES.md`. +Their use is confined to unsafe compiler auxiliaries. The pinned Lean binary +and 1,303 hashed toolchain imports remain trusted inputs. + +## Open obligations + +`REFINEMENT_PROVED` remains **OPEN** for the MAT-009 child and direct MAT-008 +parent. The model omits skipped/raw Python records, other child reasons, +several diagnostic outcomes, exceptions and observable status. Neither these +proofs nor finite tests authenticate physical evidence, independence or +classifier accuracy. The general `MAT009.partition` target in +`../theorem-map.json` remains OPEN; only its three scoped partial rows have +positive results. Future proof-source rebaselines need renewed review because +absence of a source declaration range alone is not universal compiler +provenance. + +## Local verification + +From the repository root, with the pinned Lean toolchain installed: + +```sh +python3 formal/sonification/mat009/source/source_bind.py +python3 formal/sonification/mat009/verify_evidence.py +python3 formal/sonification/mat009/lean/verify.py +python3 formal/sonification/mat009/lean/verify_negative.py +python3 formal/sonification/mat009/lean/verify_repair.py +python3 -m pytest -q tests/test_sonification_formal_mat009_lean_receipts.py tests/test_sonification_formal_mat009_negative_receipts.py tests/test_sonification_formal_mat009_suffix_axiom.py +``` + +`lean/attempts/002`, its six negative controls, the failed audit, and the +original checkpoint remain immutable research evidence. New executions use +separate directories. diff --git a/formal/sonification/theorem-map.json b/formal/sonification/theorem-map.json index e566d0e..4bdaa1e 100644 --- a/formal/sonification/theorem-map.json +++ b/formal/sonification/theorem-map.json @@ -138,7 +138,215 @@ "AUDIT_ACCEPTED": "OPEN" }, "evidence": {}, - "independent_specification_review": "PENDING" + "independent_specification_review": "PENDING", + "partial_results": [ + "MAT009.eligible_split.model", + "MAT009.diagnostic_first_owner.model", + "MAT009.eligible_split.finite_builtin_rows" + ] + }, + { + "release": "mat-spec-009-v0.1.0", + "source_tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", + "source_commit": "0758a96360726aafbb07abed34620eda178407ae", + "source_tree": "a6a03e1227e666680d656b886201ee9dde9de32d", + "source_blob": "c447f0ce76b91acf458221390ac4261166145a0b", + "source_sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", + "source_binding": "formal/sonification/mat009/source/SOURCE_BINDING.json", + "implementation": { + "path": "materials/mat_spec_009.py", + "symbol": "check_future_challenge" + }, + "id": "MAT009.eligible_split.model", + "intended_property": "Eligible-row TRAIN/HOLDOUT campaign and lab membership, sticky cross-role conflict, parent reason union, final intersection, and nonvacuous witnesses.", + "model_scope": "All finite Lean List Row values after child eligibility guards; parent reasons are arbitrary input sets. No raw Python rows or full packet semantics.", + "formal_definition": "MAT009.step, MAT009.scan and MAT009.finalize in SplitModel.lean", + "proof_path": "formal/sonification/mat009/lean/SplitModel.lean", + "typed_consumer": "formal/sonification/mat009/lean/TypedConsumer.lean", + "theorems": [ + "MAT009.Consumer.parent_reason_blocks_any_scan", + "MAT009.Consumer.shared_campaign_blocks_any_scan", + "MAT009.M009_R1_initial", + "MAT009.M009_R2_assignment_overwrite", + "MAT009.M009_R3_cross_role_trigger", + "MAT009.M009_R4_stickiness", + "MAT009.M009_R5_final_set_intersection", + "MAT009.M009_R5_parent_union", + "MAT009.M009_R6_arbitrary_finite_scan", + "MAT009.M009_R6_cross_trigger_in_finite_scan", + "MAT009.M009_R6_final_leakage_iff", + "MAT009.M009_R6_latest_owner", + "MAT009.M009_R6_parent_reason_survives", + "MAT009.M009_R7_accepted_example", + "MAT009.M009_R7_nonvacuous", + "MAT009.M009_R7_rejected_example" + ], + "theorem_statement_source": "formal/sonification/mat009/lean/attempts/003/theorem-types.json", + "proof_dependencies": [ + "Lean 4.19.0 bundled Std and Init", + "propext", + "Quot.sound", + "Classical.choice" + ], + "trusted_compiler_mechanisms": [ + "144 enumerated unsafe generated definitions", + "MAT009.initial._elambda_1", + "MAT009.step._elambda_1", + "lcProof", + "lcUnreachable" + ], + "refinement_theorem": null, + "refinement_obligations": [ + "Source-to-model and CPython correspondence for the frozen MAT009 child and direct MAT008 parent", + "Skipped/raw records, other child reasons, diagnostic conflicts and observable status", + "Representation, exceptions and production caller semantics" + ], + "executable_tests": [], + "assurance": { + "MODEL_PROVED": "PASS", + "REFINEMENT_PROVED": "OPEN", + "DIFFERENTIAL_TESTED": "OPEN", + "AUDIT_ACCEPTED": "PASS" + }, + "evidence": { + "MODEL_PROVED": [ + "formal/sonification/mat009/lean/attempts/003/result.json", + "formal/sonification/mat009/lean/attempts/003/theorem-types.json" + ], + "NEGATIVE_CONTROLS": [ + "formal/sonification/mat009/lean/recovery/005-negative-controls/result.json" + ], + "AUDIT_ACCEPTED": [ + "formal/sonification/mat009/audit/repair-audit-001/report.json" + ], + "PREVIOUS_AUDIT_FAILURE": [ + "formal/sonification/mat009/audit/report.json" + ] + }, + "independent_specification_review": "PENDING", + "audit_scope": "Exact Lean mathematical-model declarations only; prior MAT009-AUDIT-001 failure is retained; Python refinement and physical validation remain OPEN" + }, + { + "release": "mat-spec-009-v0.1.0", + "source_tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", + "source_commit": "0758a96360726aafbb07abed34620eda178407ae", + "source_tree": "a6a03e1227e666680d656b886201ee9dde9de32d", + "source_blob": "c447f0ce76b91acf458221390ac4261166145a0b", + "source_sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", + "source_binding": "formal/sonification/mat009/source/SOURCE_BINDING.json", + "implementation": { + "path": "materials/mat_spec_009.py", + "symbol": "check_future_challenge" + }, + "id": "MAT009.diagnostic_first_owner.model", + "intended_property": "A separate validated diagnostic identity registry preserves the first owner and detects a later different claimant.", + "model_scope": "Lean registry and validated identity inputs only; no Python validation, exception, or full diagnostic reason set.", + "formal_definition": "MAT009.Diagnostic.register and MAT009.Diagnostic.scan in DiagnosticFirstOwner.lean", + "proof_path": "formal/sonification/mat009/lean/DiagnosticFirstOwner.lean", + "typed_consumer": "formal/sonification/mat009/lean/TypedConsumer.lean", + "theorems": [ + "MAT009.Diagnostic.first_owner_not_last_writer", + "MAT009.Diagnostic.register_first_owner", + "MAT009.Diagnostic.register_new_owner", + "MAT009.Diagnostic.register_other_identity", + "MAT009.Diagnostic.register_preserves_existing", + "MAT009.Diagnostic.scan_first_owner_sticky" + ], + "theorem_statement_source": "formal/sonification/mat009/lean/attempts/003/theorem-types.json", + "proof_dependencies": [ + "Lean 4.19.0 bundled Std and Init", + "propext", + "Quot.sound", + "Classical.choice" + ], + "trusted_compiler_mechanisms": [ + "144 enumerated unsafe generated definitions", + "MAT009.initial._elambda_1", + "MAT009.step._elambda_1", + "lcProof", + "lcUnreachable" + ], + "refinement_theorem": null, + "refinement_obligations": [ + "Source-to-model and CPython correspondence for the frozen MAT009 child and direct MAT008 parent", + "Skipped/raw records, other child reasons, diagnostic conflicts and observable status", + "Representation, exceptions and production caller semantics" + ], + "executable_tests": [], + "assurance": { + "MODEL_PROVED": "PASS", + "REFINEMENT_PROVED": "OPEN", + "DIFFERENTIAL_TESTED": "OPEN", + "AUDIT_ACCEPTED": "PASS" + }, + "evidence": { + "MODEL_PROVED": [ + "formal/sonification/mat009/lean/attempts/003/result.json", + "formal/sonification/mat009/lean/attempts/003/theorem-types.json" + ], + "NEGATIVE_CONTROLS": [ + "formal/sonification/mat009/lean/recovery/005-negative-controls/result.json" + ], + "AUDIT_ACCEPTED": [ + "formal/sonification/mat009/audit/repair-audit-001/report.json" + ], + "PREVIOUS_AUDIT_FAILURE": [ + "formal/sonification/mat009/audit/report.json" + ] + }, + "independent_specification_review": "PENDING", + "audit_scope": "Exact Lean mathematical-model declarations only; prior MAT009-AUDIT-001 failure is retained; Python refinement and physical validation remain OPEN" + }, + { + "release": "mat-spec-009-v0.1.0", + "source_tag_object": "ad99d9e52f9ede423a4fb9d6a622624e32955263", + "source_commit": "0758a96360726aafbb07abed34620eda178407ae", + "source_tree": "a6a03e1227e666680d656b886201ee9dde9de32d", + "source_blob": "c447f0ce76b91acf458221390ac4261166145a0b", + "source_sha256": "a68089df7d1901fb7c17ffc2889b844b3573024aec4b66348f9c2ef71930c690", + "source_binding": "formal/sonification/mat009/source/SOURCE_BINDING.json", + "implementation": { + "path": "materials/mat_spec_009.py", + "symbol": "check_future_challenge" + }, + "id": "MAT009.eligible_split.finite_builtin_rows", + "intended_property": "The frozen child and a separate finite oracle agree on declared exact built-in role, campaign and lab combinations and named boundary cases.", + "finite_scope": "4096 generated four-row role/campaign/lab combinations plus focused named cases; 18 unittest methods in the retained execution. No universal Python claim.", + "formal_definition": null, + "theorems": [], + "proof_dependencies": [], + "refinement_theorem": null, + "refinement_obligations": [ + "Source-to-model and CPython correspondence for the frozen MAT009 child and direct MAT008 parent", + "Skipped/raw records, other child reasons, diagnostic conflicts and observable status", + "Representation, exceptions and production caller semantics" + ], + "executable_tests": [ + { + "path": "tests/test_sonification_formal_mat009_split.py", + "symbol": "MAT009 finite oracle and named cases" + } + ], + "assurance": { + "MODEL_PROVED": "OPEN", + "REFINEMENT_PROVED": "OPEN", + "DIFFERENTIAL_TESTED": "PASS", + "AUDIT_ACCEPTED": "PASS" + }, + "evidence": { + "DIFFERENTIAL_TESTED": [ + "formal/sonification/evidence/mat009-finite-001/receipt.json" + ], + "AUDIT_ACCEPTED": [ + "formal/sonification/mat009/audit/report.json", + "formal/sonification/mat009/audit/repair-audit-001/report.json" + ], + "PREVIOUS_AUDIT_FAILURE": [ + "formal/sonification/mat009/audit/report.json" + ] + }, + "independent_specification_review": "PENDING", + "audit_scope": "Finite source-pinned cases only; the repaired Lean gate audit does not extend finite coverage" }, { "id": "MAT010.parent", From 69a48967de4defc923c84dd6878a4119f352753c Mon Sep 17 00:00:00 2001 From: Trent Slade <73952179+EmergentMonk@users.noreply.github.com> Date: Tue, 10 Nov 2026 12:42:19 +1030 Subject: [PATCH 22/22] ci: install pinned Lean before MAT-009 receipt tests --- .github/workflows/tests.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 56170ed..ba17fe3 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -365,6 +365,7 @@ jobs: run: | curl -fsSL https://elan.lean-lang.org/elan-init.sh -o /tmp/elan-init.sh sh /tmp/elan-init.sh -y --default-toolchain leanprover/lean4:v4.19.0 + "$HOME/.elan/bin/elan" toolchain install leanprover/lean4:v4.19.0 echo "$HOME/.elan/bin" >> "$GITHUB_PATH" "$HOME/.elan/toolchains/leanprover--lean4---v4.19.0/bin/lean" --version - run: python -m pip install --upgrade pip